Les fonctions dans Kotlin

Dans ce tutoriel vous allez découvrir comment utiliser les fonctions dans Kotlin.

Les fonctions

Une fonction est un sous-programme permettant d’exécuter un ensemble d’instruction en un seul appel. Une fonction est composée d’une entête et d’un corps. Dans l’entête de la fonction se définit un identificateur, les paramètres de la fonction et le type de retour de la fonction.

Le corps de la fonction est délimité par des accolades dans lesquelles vous pouvez définir l’ensemble des instructions à exécuter.

Les fonctions dans Kotlin sont de première classe, c’est-à-dire que les fonctions dans Kotlin peuvent être affectées aux variables, passées comme argument ou renvoyées par une autre fonction.

Déclaration d’une fonction dans Kotlin.

Une fonction est déclarée en Kotlin en utilisant le mot clé fun. Voir l’exemple suivant.

fun hello() {
    println("Hello guest")
} 

Appel d’une fonction dans Kotlin

Dans Kotlin une fonction est appelée comme dans d’autre langage de programmation comme Java. Une fonction est appelée par son nom, une parenthèse ouvrante, des arguments éventuels et la parenthèse fermante. Voir l’exemple suivant de la fonction hello précédent.

 hello()

Les paramètre d’une fonction

Une fonction peut avoir zéro ou plusieurs paramètres. Les paramètres son déclarés en les parenthèses () dans l’entente de la fonction et séparés par une virgule. Les fonctions sont définies en utilisant la notation Pascal, c’est-à-dire nom :type. Chaque paramètre doit être explicitement typé. Voir l’exemple suivant

fun somme(a: Int, b: Int) {
    println("la somme de $a et $b est ${a + b}")
}

Le type de retour d’une fonction

Une fonction peut aussi retourner une valeur. Pour retourner une valeur utilisez le mot clé return. Voir l’exemple suivant

fun somme(a: Int, b: Int): Int {
    return a + b
}

Les valeurs par défaut des paramètres d’une fonction dans Kotlin.

Les paramètres de fonction peuvent avoir des valeurs par défaut, qui sont utilisées lorsqu’aucune valeur n’est définie pour l’argument correspondant lors de l’appelle de la fonction. Voir l’exemple suivant.

fun somme(a: Int = 3, b: Int = 4): Int {
    return a + b
}

fun main() {
    val s = somme()
    println("Le calcul de la somme est : $s")
}

Dans cet exemple la fonction somme est appelée sans passer d’arguments, ce sont les valeurs par défaut des paramètres de la fonction somme qui sont utilisées.

Les arguments nommés

Lorsqu’une fonction à beaucoup de paramètre, cela peut devenir difficile lors de l’appel de d’une fonction d’associer une valeur à un argument, pour cela Kotlin vous permet de nommer un à plusieurs arguments.

Lorsque vous nommez les arguments dans un appel de fonction, vous pouvez modifier l’ordre dans lequel ils sont spécifiés. Voir l’exemple suivant

fun somme(a: Int = 3, b: Int = 4) {
    println("La somme de $a et $b est ${a + b}")
}

fun main() {
    somme(b = 10, a = 5)
}

Dans cet exemple, vous pouvez constater que les arguments sont spécifiés dans un ordre différent de l’ordre dans lequel ils sont déclarés.

Si vous souhaitez plutôt que les valeurs par défaut des arguments soit utiliser, vous omettez simplement les arguments lors de l’appel de la fonction. Voir l’exemple suivant.

Prenons comme exemple la fonction somme suivante dont les paramètre ont une valeur par défaut.

fun somme(a: Int = 3, b: Int = 4) {
    println("La somme de $a et $b est ${a + b}")
}

fun main() {
    somme()
}

Vous constatez bien que la fonction somme est appelée sans arguments.

Lorsque vous appelez la fonction somme, vous n’avez pas à nommer tous les arguments. Voir l’exemple

fun somme(a: Int = 3, b: Int = 4) {
    println("La somme de $a et $b est ${a + b}")
}

fun main() {
    somme(5,b = 10)
}

Vous constatez bien dans cet exemple que seul l’argument b de la fonction somme est nommé

Si par contre vous omettez les arguments qui ont une valeur par défaut, après avoir omis le premier argument, vous devez nommer tous les arguments restant. Voir l’exemple suivant.

fun somme(a: Int = 3, b: Int = 4, c: Int = 3, d: Int = 12) {
    println("La somme de $a, $b, $c et $d  est ${a + b + c + d}")
}

fun main() {
    somme(5, b = 10, c = 7, d = 8)
}

Le type de retour Unit(vide en Kotlin)

Les fonctions en Kotlin doivent spécifier leur type de retour. Si la fonction ne retourne aucune valeur, sont type de retour est Unit. Le type de retour Unit peut-être omit en Kotlin. Voir l’exemple suivant.

fun somme(a: Int = 3, b: Int = 4, c: Int = 3, d: Int = 12): Unit {
    println("La somme de $a, $b, $c et $d  est ${a + b + c + d}")
}

Dans cet exemple, la fonction somme ne renvoie aucune valeur, donc son type de retour est Unit. Le type de retour Unit peut-être omit comme suit

fun somme(a: Int = 3, b: Int = 4, c: Int = 3, d: Int = 12){
    println("La somme de $a, $b, $c et $d  est ${a + b + c + d}")
}

Les fonctions d’expression unique en Kotlin

Lorsqu’une fonction contient une seule expression, les accolades peuvent être omises. Le corps de la fonction est spécifié après le signe =. Voir l’exemple suivant

fun somme(a: Int, b: Int) = a + b

Le nombre variable d’argument en Kotlin

Les fonctions en Kotlin peuvent avoir un nombre variable d’arguments.On déclare une fonction possedant un nombre variable d’argument avec le mot clé vararg. Voir l’exemple suivant

fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts is an Array
        result.add(t)
    return result
}

fun main() {
    val list = asList(1, 2, 3)
}

La portée des fonctions dans Kotlin

Dans Kotlin, les fonctions peuvent être déclarées directement dans un fichier, ce qui signifie que vous n’avez pas besoin de créer une classe pour contenir une fonction, elles peuvent également être déclarées locales, en tant que fonctions membres et fonctions d’extension.

Les fonctions locales de Kotlin

Kotlin supporte les fonctions locales, c’est-à-dire une fonction définie dans une fonction. Voir l’exemple suivant.

fun somme(nb: Int): Int {
    var value = nb

    fun add() {
        value++
    }
    for (i in 1..10) {
        add()
    }
    return value
}

fun main() {
    val result = somme(10)
    println("La somme total est $result")
}

Les fonctions locales peuvent accéder au variables locales des fonctions externes. Voir l’exemple suivant. C’est le cas de la variable value.

Les fonctions membres de Kotlin

Les fonctions membres sont des fonctions définies dans une classe ou un object.Voir l’exemple suivant.

class  Operation{
    fun somme(a:Int,b:Int)=a+b
}

Les fonctions membres sont appelées en utilisant la notation pointée.Voir l’exemple suivant

fun main() {
    val operation = Operation()
    val s = operation.somme(1, 7)

}

Les fonctions d’extension de Kotlin

Les fonctions d’extension sont expliquées dans le tutoriel suivant.

Conclusion

Dans ce tutoriel, nous avons abordé les fonctions dans Kotlin, comment les déclarées, les différents types de fonction et comment appeler une fonction. J’espère que ce tutoriel vous aidera à utiliser les fonctions dans vos prochaines applications. À bientôt pour un autre tutoriel