Passer une fonction en paramètre dans Kotlin : guide complet pour débutants

Kotlin : comment passer une fonction en paramètre ? On analyse avec des exemples

Bonjour, ami ! Si tu as déjà programmé en Kotlin et que tu t'es demandé : "Comment passer une fonction en paramètre à une autre fonction ?" — alors tu es au bon endroit. Cette question sur Stack Overflow a rassemblé des milliers de vues, et ce n'est pas surprenant. La programmation fonctionnelle en Kotlin n'est pas seulement une fonctionnalité à la mode, mais un outil puissant qui rend le code plus propre, plus court et plus expressif.

Dans cet article, nous ne donnerons pas simplement une réponse sèche. Nous allons tout détailler, des expressions lambda simples aux techniques avancées. Tu apprendras à utiliser les types Function, l'opérateur de référence de fonction ::, et même à éviter les erreurs typiques des débutants. C'est parti !

Pourquoi est-ce important ? Trois raisons d'utiliser les fonctions comme paramètres

\n
• Flexibilité : Tu peux écrire une seule fonction qui fera différentes choses selon la fonction que tu lui passes.
\n
• Lisibilité : Le code devient déclaratif — tu décris ce qu'il faut faire, pas comment le faire.
\n
• Réutilisabilité : Tu évites la duplication de code en extrayant les motifs communs dans des fonctions d'ordre supérieur.
\n

Les bases : les types de fonctions (Function Types)

En Kotlin, les fonctions sont des objets de première classe. Cela signifie qu'elles ont leur propre type. Le type d'une fonction se décrit ainsi : (Paramètres) -> TypeDeRetour. Par exemple :

// Fonction qui prend un Int et retourne une String\nval intToString: (Int) -> String = { number -> "Nombre : $number" }\n\n// Fonction qui ne prend rien et ne retourne rien\nval doNothing: () -> Unit = { println("Bonjour !") }\n\n// Fonction avec deux paramètres\nval sum: (Int, Int) -> Int = { a, b -> a + b }\n

Remarque Unit — c'est l'équivalent de void en Java/JavaScript. Si une fonction ne retourne rien, son type est () -> Unit.

Comment passer une fonction en paramètre : premier exemple

Supposons que nous écrivions une fonction qui effectue une opération sur un nombre deux fois. Au lieu de coder en dur l'opération, nous allons la passer en paramètre :

fun applyTwice(x: Int, operation: (Int) -> Int): Int {\n    val firstResult = operation(x)\n    return operation(firstResult)\n}\n\n// Utilisation :\nval result = applyTwice(5) { it * 2 } // Lambda\nprintln(result) // Affiche : 20 (5*2 = 10, 10*2 = 20)\n\n// Ou avec une fonction nommée :\nfun double(x: Int) = x * 2\nval result2 = applyTwice(5, ::double)\nprintln(result2) // Affiche aussi 20\n

Tu vois comme c'est élégant ? Dans le premier cas, nous avons utilisé une expression lambda (fonction anonyme), et dans le second, une référence à une fonction existante via l'opérateur ::. Les deux méthodes sont valides, et nous allons les détailler.

Méthodes pour passer une fonction (analyse détaillée)

1. Expressions lambda (la méthode la plus populaire)

Une lambda est une fonction anonyme que l'on peut passer directement. En Kotlin, les lambdas ont une syntaxe concise :

val list = listOf(1, 2, 3, 4, 5)\n\n// On passe une lambda à la fonction filter\nval evenNumbers = list.filter { it % 2 == 0 }\nprintln(evenNumbers) // [2, 4]\n\n// Avec plusieurs paramètres :\nval numbersWithIndex = list.mapIndexed { index, value -> "$index : $value" }\nprintln(numbersWithIndex) // ["0 : 1", "1 : 2", ...]\n

Important : Si la lambda est le dernier paramètre de la fonction, on peut la placer en dehors des parenthèses. Cela rend le code similaire aux constructions intégrées du langage. C'est ainsi que fonctionnent filter, map, forEach et autres.

Exemple avec indication explicite du paramètre (lorsqu'il y a plus d'un paramètre) :

fun performAction(a: Int, b: Int, action: (Int, Int) -> String) {\n    println(action(a, b))\n}\n\n// Appel avec une lambda\nperformAction(3, 4) { x, y -> "Somme : ${x + y}" }\n