Utilisation des fonctions de scoping dans Kotlin

1. Fonctions d’étendue dans Kotlin
2. Utiliser les fonctions d’étendue dans Kotlin
3. Utiliser la fonction de portée also dans Kotlin
4. Utiliser la fonction let Scope dans Kotlin
5. Utiliser la fonction d’étendue apply dans Kotlin
6. Utiliser la fonction d’étendue run dans Kotlin
7. Utiliser la fonction d’étendue with dans Kotlin

Cet article traitera de la fonction scope also dans Kotlin. Nous passerons également en revue les autres fonctions de portée disponibles dans Kotlin.

Mais d’abord, comprenons ce que sont les fonctions de portée.

Fonctions d’étendue dans Kotlin

Kotlin a de nombreuses fonctions créées uniquement pour exécuter un morceau de code dans le contexte d’un objet. Ces fonctions sont appelées les fonctions de portée.

Les fonctions de portée créent une portée temporaire pour l’objet lorsque nous les appelons avec une expression lambda. Il existe 5 fonctions d’étendue dans Kotlin, à savoir also, let, apply, run et with.

Alors que toutes les fonctions de portée dans Kotlin remplissent la même fonction, ce qui est différent, c’est la façon dont l’objet à l’intérieur de ce bloc est disponible après l’exécution. En fonction de la valeur de retour et de la référence de l’objet, nous devons choisir l’une des cinq fonctions de portée.

Le tableau ci-dessous montre la référence d’objet et la valeur de retour de chaque fonction d’étendue.

Utiliser les fonctions d’étendue dans Kotlin

L’exemple ci-dessous illustre l’utilisation des fonctions de portée dans Kotlin. Dans ce code, nous allons utiliser la fonction let pour créer la portée de l’objet Students.

data class Student(var firstName: String, var lastName: String, var age: Int, var address: String) {
    fun moving(newAddress: String) { address = newAddress }
    fun ageIncrease() { age++ }
}

fun main() {
    Student("David", "Miller", 24, "New York").let {
        println(it)
        it.moving("Chicago")
        it.ageIncrease()
        println(it)
    }
}

Production:

La fonction scope fait référence à l’objet Student en tant que it dans la sortie. Sans utiliser la fonction scope, nous aurions dû déclarer une nouvelle variable et l’initialiser avec la valeur de l’objet Student pour y accéder.

Utiliser la fonction de portée also dans Kotlin

Comme mentionné dans le tableau ci-dessus, la fonction also de Kotlin fournit un objet de contexte en tant qu’argument (it). Nous pouvons utiliser also lorsque nous devons effectuer des actions qui prennent l’objet de contexte comme argument de n’importe quelle fonction.

Une autre excellente façon d’utiliser also dans Kotlin est lorsque nous avons besoin d’une référence directe à l’objet lui-même et non à ses propriétés ou à sa fonction. Considérez l’exemple ci-dessous pour comprendre la fonction also dans Kotlin.

fun main() {
    val numList = mutableListOf("one", "three", "five")
    numList
        .also { println("Elements in the list before adding a new one: $it") }
        .add("seven")
        println("Elements in the list after adding a new one: " + numList)
}

Production:

Utiliser la fonction let Scope dans Kotlin

La fonction de portée let dans Kotlin fournit l’objet de contexte en tant qu’argument it. Sa valeur de retour est le résultat de l’exécution lambda.

Nous pouvons utiliser la fonction let pour invoquer plusieurs fonctions afin d’accumuler les résultats des chaînes d’appels.

fun main() {
    val numList = mutableListOf("one", "three", "five", "seven", "nine")
    val resList = numList.map { it.length }.filter { it > 3 }
    println(resList)
}

Production:

[5,4,5,4]

Au lieu d’utiliser la resList dans l’exemple ci-dessus, nous pouvons utiliser la fonction de portée let pour imprimer les résultats lambda.

fun main() {
    val numList = mutableListOf("one", "three", "five", "seven", "nine")
    numList.map { it.length }.filter { it > 3 }.let{
        println(it)
        //We can add more functions here
    }
}

Production:

[5,4,5,4]

Si le code n’a qu’une seule fonction, nous pouvons remplacer le lambda (it) par le symbole de référence de méthode (::).

fun main() {
    val numList = mutableListOf("one", "three", "five", "seven", "nine")
    numList.map { it.length }.filter { it > 3 }.let(::println)
}

Production:

[5,4,5,4]

Utiliser la fonction d’étendue apply dans Kotlin

Lors de l’utilisation de la fonction apply en Kotlin (this), l’objet contextuel est disponible comme récepteur. Nous pouvons utiliser la fonction apply sur des blocs de code qui n’ont pas de valeur de retour.

Le cas d’utilisation le plus courant est lors de la configuration de l’objet. Considérez l’exemple ci-dessous où nous créons un objet Student, puis le configurons.

data class Student(var Name: String, var age: Int = 0, var address: String = "")

fun main() {
    val david = Student("David Miller").apply {
        age = 24
        address = "New York"
    }
    println(david)
}

Production:

Utiliser la fonction d’étendue run dans Kotlin

Nous obtenons l’objet de contexte en tant que récepteur (this) en utilisant la fonction run de Kotlin. Le résultat de l’exécution lambda est lui-même la valeur de retour pour cette fonction de portée.

La fonction run est plus utile lorsque lambda a à la fois l’initialisation de l’objet et le calcul de la valeur de retour.

class port(var url: String, var portNum: Int) {
    fun initialRequest(): String = "Initial default request"
    fun res(request: String): String = "This is the result of query '$request'"
}

fun main() {

    val portService = port("https://example.kotlinlang.org", 80)

    val finalResult = portService.run {
        portNum = 8080
        res(initialRequest() + " to port $portNum")
    }
    // the same code written with let() function:
    val letResult = portService.let {
        it.portNum = 8080
        it.res(it.initialRequest() + " to port ${it.portNum}")
    }
    println(finalResult)
    println(letResult)
}

Production:

Nous pouvons également utiliser run dans Kotlin en tant que fonction sans extension. Cela signifie qu’il exécutera un bloc d’instructions qui nécessite des expressions.

fun main() {
    val hexNum = run {
        val dig = "0-9"
        val hexDig = "A-Fa-f"
        val indication = "+-"
        Regex("[$indication]?[$dig$hexDig]+")
    }
    for (match in hexNum.findAll("+139 -ABFF 79")) {
        println(match.value)
    }
}

Production:

+139
-ABFF
79

Utiliser la fonction d’étendue with dans Kotlin

La fonction with est également une fonction sans extension, comme run. Le truc avec la fonction with, c’est qu’elle est passée en argument mais disponible en récepteur.

Le with est mieux utilisé pour appeler des fonctions sur l’objet de contexte où nous ne voulons pas fournir les résultats lambda.

fun main() {
    val num = mutableListOf("one", "three", "five", "seven")
    with(num) {
        println("The function 'with' is called with argument $this")
        println("The function contains $size items")
    }
}

Production: