Les lambdas (ou expressions lambdas) sont des fonctions anonymes qui peuvent être utilisées comme des expressions régulières dans le code.
Elles sont très utiles pour réduire la complexité du code et nous permette de créer des fonctions réutilisables et lisibles.
Kotlin prend en charge les lambdas de manière native, ce qui les rend relativement faciles à utiliser au quotidien.
Déclaration d’une lambda
Exemple général d’une déclaration de lambda :
val lambdaName: (parameterType: parameterName) -> returnType =
{ parameterName ->
// code à exécuter
}Qui peut donc ressembler à ça :
val add: (Int, Int) -> Int = { x, y -> x + y }Cette déclaration crée une variable nommée “add” qui prend en entrée deux paramètres de type Int et retourne un Int.
Le code à l’intérieur de la lambda est celui qui sera exécuté lorsque la fonction sera appelée.
Appeler une lambda
La syntaxe suivante permet d’appeler la lambda précedemment créée :
val result = add(2, 3)La lambda “add” avec les paramètres 2 et 3 est donc appelée, et le résultat sera stocké à l’intérieur de la variable “result“
Utilisation d’une lambda en tant qu’expression
Les lambdas peuvent également être utilisées en tant qu’expressions, comme dans les fonctions de haut niveau telles que map, filter, etc.
Par exemple :
val numbers = listOf(1, 2, 3, 4, 5)
val doubledNumbers = numbers.map { it * 2 }Ce bout code utilise la fonction map pour doubler tous les nombres dans la liste “numbers” en utilisant une lambda en tant qu’expression.
Une syntaxe concise pour les lambdas
Kotlin 1.8 a introduit une syntaxe concise pour les lambdas, permettant de créer des fonctions anonymes plus facilement et de manière plus lisible.
Par exemple :
val numbers = listOf(1, 2, 3, 4, 5)
fun timesTwo(n: Int) = n * 2
val doubledNumbers = numbers.map(::timesTwo)
// output : [2, 4, 6, 8, 10]Ce code utilise la fonction map pour doubler tous les nombres dans la liste “numbers” en utilisant une fonction nommée timesTwo.
Passage de paramètre par nom
En plus de passer des paramètres par valeur, Kotlin permet également de passer des paramètres par nom.
Cela signifie que nous pouvons utiliser le nom du paramètre plutôt que sa position pour spécifier les paramètres lorsque vous appelez une fonction.
Par exemple :
val numbers = listOf(1, 2, 3, 4, 5)
val filteredNumbers = numbers.filter { n -> n > 2 }
// output : [3, 4, 5]Ce code utilise la fonction filter pour filtrer les nombres dans la liste “numbers” qui sont supérieurs à 2.
Accès aux variables extérieures
Les lambdas ont également accès aux variables extérieures déclarées dans leur portée.
Cela signifie qu’elles peuvent utiliser les variables déclarées en dehors de leur propre portée.
Par exemple :
val max = 3
val numbers = <em>listOf</em>(1, 2, 3, 4, 5)
val filteredNumbers = numbers.<em>filter </em><strong>{ it </strong>< max <strong>}</strong>
// output : [1, 2]Ce code utilise la fonction filter pour filtrer les nombres dans la liste “numbers” qui sont inférieurs à la variable “max“.
En résumé, les lambdas sont des fonctions anonymes qui peuvent être utilisées comme des expressions régulières dans le code.
Kotlin les prend en charge de manière native, ce qui les rend faciles à utiliser.
Vous pouvez les déclarer et les appeler en utilisant la syntaxe standard, les utiliser en tant qu’expression dans les fonctions de haut niveau, et enfin utiliser la syntaxe concise pour une lisibilité accrue.
Les lambdas sont un outil puissant pour la création de code réutilisable et lisible, et sont un élément clé de la programmation fonctionnelle en Kotlin.
