Fonctions de portée Kotlin à envoyer aux développeurs Java

Qu'est-ce qu'une fonction d'étendue?

Fonctions génériques définies dans la bibliothèque standard de Kotlin. Puisqu'il s'agit d'une fonction générique, elle peut être appliquée à n'importe quel type. En utilisant la fonction scope, vous pouvez écrire plus de code de type Kotlin.

laisser et courir

C'est une image comme la fonction de carte de Stream.

val str: String = "5963"

//Convertir la variable str en Int
//Lors de l'utilisation de let
val i: Int = str.let { it.toInt() }

//Convertir la variable str en Int
//Lors de l'utilisation de run
val i2: Int = str.run { this.toInt() }

L'expression lambda qui suit «let» a un argument. Cet argument est une référence à «str». L'expression lambda qui suit run n'a pas d'arguments. Au lieu de cela, cette référence dans cette expression lambda est «str». Le résultat de l'expression lambda est la valeur de retour de let et run.

En outre, l'objet que la fonction est appelée, comme la variable str dans cet exemple, est appelé l'objet ** Lacy bar **.

Où utiliser

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

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

    return makeGreeting(name)
}

Dans la fonction greet () Passez le résultat de getName () à la fonctionmakeGreeting ()et Le résultat est la valeur de retour de la fonction greet ().

Cependant, la valeur de retour de getName () est un type à tolérance nulle, donc une vérification nulle est requise une fois. Réécrivons ceci en utilisant let.

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

Appelez let avec un appel sûr au résultat de getName (). De cette façon, vous pouvez écrire assez proprement. Ceci est utile pour les appels sécurisés et pour transmettre le résultat d'une conversion sécurisée à un argument de fonction. (Bien sûr, il est également souvent utilisé dans d'autres cas.)

appliquer et aussi

Similaire à let and run, mais la valeur de retour est toujours l'objet récepteur.

val str: String = "5963"

//Sortie standard de la variable str
//Quand est également utilisé
val str2: String = str.also { print(it) }

//Sortie standard de la variable str
//Lors de l'utilisation appliquer
val str3: String = str.apply { print(this) }

Où utiliser

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
}

La fonction registerNewPerson crée une nouvelle instance de Person et la renvoie. Il initialise simplement Person, mais il doit être placé une fois dans une variable.

Utilisons «aussi».

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

Il peut être implémenté sans créer de variable temporaire pour Person. Lorsque vous traitez avec des objets qui ne sont pas des modèles Builder, etc. Puisque le processus d'initialisation de l'objet est organisé dans la fonction scope, il conduit à une meilleure lisibilité.

with

avec est un peu étrange. C'est comme run, qui passe l'objet récepteur comme argument.

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

Où utiliser

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

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

Utilisez avec pour en faire une fonction d'expression unique. Cette référence changera et pourra être écrite dans un contexte différent.