Kotlin-Scope-Funktionen zum Senden an Java-Entwickler

Was ist eine Scope-Funktion?

Generische Funktionen, die in der Standardbibliothek von Kotlin definiert sind. Da es sich um eine generische Funktion handelt, kann sie auf jeden Typ angewendet werden. Mit der Scope-Funktion können Sie mehr Kotlin-ähnlichen Code schreiben.

lass und renne

Es ist ein Bild wie die Kartenfunktion von Stream.

val str: String = "5963"

//Konvertieren Sie die Variable str in Int
//Bei Verwendung let
val i: Int = str.let { it.toInt() }

//Konvertieren Sie die Variable str in Int
//Bei Verwendung von run
val i2: Int = str.run { this.toInt() }

Der Lambda-Ausdruck, der auf "let" folgt, hat ein Argument. Dieses Argument bezieht sich auf "str". Der Lambda-Ausdruck nach "run" hat keine Argumente. Stattdessen lautet diese Referenz in diesem Lambda-Ausdruck "str". Das Ergebnis des Lambda-Ausdrucks ist der Rückgabewert von "let" und "run".

Das Objekt, das die Funktion aufruft, wie beispielsweise die Variable "str" in diesem Beispiel, wird auch als "Racer-Objekt" bezeichnet.

Wo zu verwenden

fun getName(): String? = ""
fun makeGreeting(name: String) = "Hello, $name"

fun greet(): String? {
    val name = getName()
    if (name == null) {
        return null
    }

    return makeGreeting(name)
}

In der Funktion greet () Übergeben Sie das Ergebnis von getName () an diemakeGreeting ()Funktion und Das Ergebnis ist der Rückgabewert der Funktion greet ().

Der Rückgabewert von "getName ()" ist jedoch ein null-toleranter Typ, sodass einmal eine Nullprüfung erforderlich ist. Lassen Sie uns dies mit let umschreiben.

fun greet(): String? {
    return getName()?.let { makeGreeting(it) }
}

Rufen Sie let mit einem sicheren Aufruf des Ergebnisses von getName () auf. Auf diese Weise können Sie ziemlich ordentlich schreiben. Dies ist nützlich für sichere Aufrufe und zum Übergeben des Ergebnisses einer sicheren Umwandlung an ein Funktionsargument. (Natürlich wird es auch oft in anderen Fällen verwendet.)

bewerben und auch

Ähnlich wie let and run, aber der Rückgabewert ist immer das Empfängerobjekt.

val str: String = "5963"

//Standardausgabe der Variablen str
//Wenn auch verwendet wird
val str2: String = str.also { print(it) }

//Standardausgabe der Variablen str
//Bei der Anwendung anwenden
val str3: String = str.apply { print(this) }

Wo zu verwenden

class Person {
    var firstName: String? = null
    var middleName: String? = null
    var lastName: String? = null
}

fun registerNewPerson() : Person {
    val person = Person()
    person.firstName = "Kumiko"
    person.middleName = "Susan"
    person.lastName = "Yamamoto"
    return person
}

Die Funktion "registerNewPerson" erstellt eine neue Instanz von "Person" und gibt sie zurück. Es initialisiert nur "Person", muss aber einmal in eine Variable eingefügt werden.

Verwenden wir "auch".

fun registerNewPerson() : Person {
    return Person().also {
        it.firstName = "Kumiko"
        it.middleName = "Susan"
        it.lastName = "Yamamoto"
    }
}

Es kann implementiert werden, ohne eine temporäre Variable für "Person" zu erstellen. Beim Umgang mit Objekten, die keine Builder-Muster usw. sind. Da der Initialisierungsprozess des Objekts in der Bereichsfunktion organisiert ist, führt dies zu einer verbesserten Lesbarkeit.

with

mit ist ein wenig seltsam. Es ist wie "run", das das Empfängerobjekt als Argument übergibt.

val str = "5963"
val i: Int = with(str) { this.toInt() }

Wo zu verwenden

class Greeter {
    fun greet(): String = "Hello, world"
}

fun greet(greeter: Greeter) = with(greeter) { 
    greet()
}

Verwenden Sie diese Option, um eine einzelne Ausdrucksfunktion zu erstellen. Diese Referenz ändert sich und kann in einem anderen Kontext geschrieben werden.