Verwendung von Scoping-Funktionen in Kotlin

1. Bereichsfunktionen in Kotlin
2. Verwendung von Scope-Funktionen in Kotlin
3. Verwendung von die Scope-Funktion auch in Kotlin
4. Verwendung der Bereichsfunktion let in Kotlin
5. Verwendung von die Scope-Funktion apply in Kotlin
6. Verwendung von die Scope-Funktion run in Kotlin
7. Verwendung von die with Scope-Funktion in Kotlin

In diesem Artikel wird die Scope-Funktion auch in Kotlin besprochen. Wir werden auch die anderen in Kotlin verfügbaren Bereichsfunktionen durchgehen.

Aber zuerst wollen wir verstehen, was Scope-Funktionen sind.

Bereichsfunktionen in Kotlin

Kotlin verfügt über viele Funktionen, die ausschließlich zum Ausführen eines Codes im Kontext eines Objekts erstellt wurden. Diese Funktionen werden als Bereichsfunktionen bezeichnet.

Bereichsfunktionen erstellen einen temporären Bereich für das Objekt, wenn wir sie mit einem Lambda-Ausdruck aufrufen. Es gibt 5 Scope-Funktionen in Kotlin, nämlich also, let, apply, run und with.

Während alle Bereichsfunktionen in Kotlin dieselbe Funktion ausführen, besteht der Unterschied darin, wie das Objekt innerhalb dieses Blocks nach der Ausführung verfügbar ist. Basierend auf dem Rückgabewert und der Objektreferenz müssen wir eine der fünf Scope-Funktionen auswählen.

Die folgende Tabelle zeigt die Objektreferenz und den Rückgabewert jeder Bereichsfunktion.

Verwendung von Scope-Funktionen in Kotlin

Das folgende Beispiel zeigt die Verwendung von Bereichsfunktionen in Kotlin. In diesem Code verwenden wir die Funktion let, um den Gültigkeitsbereich für das Objekt Students zu erstellen.

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)
    }
}

Ausgabe:

Die Scope-Funktion bezieht sich in der Ausgabe auf das Student-Objekt als it. Ohne die Scope-Funktion hätten wir eine neue Variable deklarieren und mit dem Wert des Student-Objekts initialisieren müssen, um darauf zugreifen zu können.

Verwendung von die Scope-Funktion auch in Kotlin

Wie in der obigen Tabelle erwähnt, liefert die also-Funktion in Kotlin ein Kontextobjekt als Argument (it). Wir können auch verwenden, wenn wir Aktionen ausführen müssen, die das Kontextobjekt als Argument einer beliebigen Funktion verwenden.

Eine weitere großartige Möglichkeit, also in Kotlin zu verwenden, ist, wenn wir einen direkten Verweis auf das Objekt selbst und nicht auf seine Eigenschaften oder Funktion benötigen. Betrachten Sie das folgende Beispiel, um die Funktion auch in Kotlin zu verstehen.

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)
}

Ausgabe:

Verwendung der Bereichsfunktion let in Kotlin

Die Scope-Funktion let in Kotlin liefert das Kontextobjekt als Argument it. Sein Rückgabewert ist das Ergebnis der Lambda-Ausführung.

Wir können die let-Funktion verwenden, um mehrere Funktionen aufzurufen, um Ergebnisse von Aufrufketten zu akkumulieren.

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

Ausgabe:

[5,4,5,4]

Anstatt die resList im obigen Beispiel zu verwenden, können wir die Scope-Funktion let verwenden, um die Lambda-Ergebnisse zu drucken.

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
    }
}

Ausgabe:

[5,4,5,4]

Wenn der Code nur eine Funktion hat, können wir das Lambda (it) durch das Methodenreferenzsymbol (::) ersetzen.

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

Ausgabe:

[5,4,5,4]

Verwendung von die Scope-Funktion apply in Kotlin

Bei Verwendung der apply-Funktion in Kotlin (this) steht das Context-Objekt als Empfänger zur Verfügung. Wir können die apply-Funktion auf Codeblöcke anwenden, die keinen Rückgabewert haben.

Der häufigste Anwendungsfall ist die Objektkonfiguration. Betrachten Sie das folgende Beispiel, in dem wir ein Student-Objekt erstellen und es dann konfigurieren.

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)
}

Ausgabe:

Verwendung von die Scope-Funktion run in Kotlin

Wir erhalten das Kontextobjekt als Empfänger (this), indem wir die Funktion run in Kotlin verwenden. Das Ergebnis der Lambda-Ausführung ist selbst der Rückgabewert für diese Bereichsfunktion.

Die run-Funktion ist am hilfreichsten, wenn Lambda sowohl die Objektinitialisierung als auch die Berechnung des Rückgabewerts hat.

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)
}

Ausgabe:

Wir können run in Kotlin auch als Nicht-Erweiterungsfunktion verwenden. Dies bedeutet, dass ein Anweisungsblock ausgeführt wird, der Ausdrücke erfordert.

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)
    }
}

Ausgabe:

+139
-ABFF
79

Verwendung von die with Scope-Funktion in Kotlin

Die with-Funktion ist auch eine Nicht-Erweiterungsfunktion, wie run. Die Sache mit der with-Funktion ist, dass sie als Argument übergeben wird, aber als Empfänger verfügbar ist.

Das with wird am besten zum Aufrufen von Funktionen für das Kontextobjekt verwendet, bei dem wir die Lambda-Ergebnisse nicht bereitstellen möchten.

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")
    }
}

Ausgabe: