PricingLoginStart free
Kotlin Academy · Leçon

Transmettre des lambdas à des fonctions

Transmettez des lambdas comme arguments et utilisez la syntaxe de lambda finale.

Leçon 2 sur 413 étapes

Transmettre des lambdas à des fonctions est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Fonctions acceptant des lambdas

Une fonction de niveau supérieur est une fonction qui reçoit une fonction, telle qu’une lambda, comme paramètre. C’est ainsi que fonctionnent map, filter et forEach.

Déclarer une fonction de niveau supérieur

Utilisez un type de fonction comme type du paramètre.
fun applyTwice(n: Int, op: (Int) -> Int): Int {
    return op(op(n))
}
println(applyTwice(3, { it * 2 }))  // 12

Syntaxe de la lambda finale

Si le dernier paramètre est une fonction, vous pouvez déplacer la lambda en dehors des parenthèses. C’est la syntaxe de la « lambda finale ».
fun applyTwice(n: Int, op: (Int) -> Int) = op(op(n))

// Standard:
applyTwice(3, { it * 2 })
// Trailing lambda:
applyTwice(3) { it * 2 }

Lambda finale sans parenthèses

Lorsque la lambda est le seul argument, vous pouvez omettre entièrement les parenthèses.
fun execute(block: () -> Unit) = block()

// With parens:
execute({ println("Hello") })
// Without parens (idiomatic):
execute { println("Hello") }

Transmettre une variable contenant une lambda

Vous pouvez transmettre une référence de lambda stockée en utilisant le nom de sa variable.
val double = { n: Int -> n * 2 }
fun applyTwice(n: Int, op: (Int) -> Int) = op(op(n))
println(applyTwice(5, double))  // 20

Références de fonctions avec ::

Utilisez :: pour transmettre une fonction nommée comme argument compatible avec une lambda.
fun triple(n: Int) = n * 3
fun applyTwice(n: Int, op: (Int) -> Int) = op(op(n))
println(applyTwice(2, ::triple))  // 18

Plusieurs paramètres lambda

Une fonction peut accepter plusieurs paramètres lambda. Seul le dernier peut utiliser la syntaxe de lambda finale.
fun transform(
    value: Int,
    before: (Int) -> Int,
    after: (Int) -> Int
) = after(before(value))

println(transform(5, { it * 2 }, { it + 1 }))  // 11

Transmettre une lambda à filter

La fonction filter accepte une lambda prédicat, c’est-à-dire une fonction qui associe un élément à une valeur booléenne.
val numbers = listOf(1, 2, 3, 4, 5, 6)
val evens = numbers.filter { it % 2 == 0 }
println(evens)  // [2, 4, 6]

Chaîner des fonctions d’ordre supérieur

Chaînez plusieurs appels de fonctions d’ordre supérieur pour créer des chaînes de traitement de données expressives.
val result = (1..10)
    .filter { it % 2 != 0 }  // odds
    .map { it * it }          // square
    .take(3)                  // first 3
println(result)  // [1, 9, 25]

Capture de variables par une lambda

Les lambdas peuvent capturer des variables de la portée environnante (fermeture). En Kotlin, elles peuvent même capturer et modifier une variable déclarée avec var.
var total = 0
listOf(1, 2, 3, 4).forEach { total += it }
println(total)  // 10

Retourner une lambda depuis une fonction

Les fonctions d’ordre supérieur peuvent également retourner des lambdas, ce qui permet de créer des fonctions fabriques.
fun multiplierOf(factor: Int): (Int) -> Int {
    return { n -> n * factor }
}
val double = multiplierOf(2)
val triple = multiplierOf(3)
println(double(5))  // 10
println(triple(5))  // 15

Vérification rapide

Quand pouvez-vous déplacer une lambda en dehors des parenthèses à l’aide de la syntaxe de lambda finale ?
Réponds-y dans la leçon interactive

Récapitulatif

Les fonctions d’ordre supérieur acceptent des lambdas comme paramètres. La syntaxe de lambda finale déplace la lambda en dehors des parenthèses lorsqu’elle est la dernière. :: transmet des références vers des fonctions nommées. Ensuite : le paramètre implicite it !
Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
51
Leçons
203
Commencer gratuitementVoir le cours complet

Questions Fréquemment Posées

La leçon « Transmettre des lambdas à des fonctions » est-elle gratuite ?

Oui — le texte complet de « Transmettre des lambdas à des fonctions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Transmettre des lambdas à des fonctions » ?

Transmettez des lambdas comme arguments et utilisez la syntaxe de lambda finale. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Transmettre des lambdas à des fonctions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Qu’est-ce qu’une lambda ? Syntaxe et types
  2. Transmettre des lambdas à des fonctions
  3. it : le paramètre implicite
  4. filter, map et find sur les collections
← Retour à Kotlin Academy