Kotlin
Grundlegende Lambdas

Android firebase iOS Java Language javafx JavaScript Regular Expressions Scala Language spring spring-boot
Suche…


Syntax

  • Explizite Parameter:

  • {parameterName: ParameterType, otherParameterName: OtherParameterType -> anExpression ()}

  • Abgeleitete Parameter:

  • Addition: (Int, Int) -> Int = {a, b -> a + b}

  • Einzelne Parameter it Kurzschrift

  • val square: (Int) -> Int = {it * it}

  • Unterschrift:

  • () -> ResultType

  • (Eingabetyp) -> ResultType

  • (InputType1, InputType2) -> ResultType

Bemerkungen

Eingabetypparameter können ausgelassen werden, wenn sie ausgelassen werden können, wenn sie aus dem Kontext abgeleitet werden können. Angenommen, Sie haben eine Funktion für eine Klasse, die eine Funktion übernimmt: 

data class User(val fistName: String, val lastName: String) {
    fun username(userNameGenerator: (String, String) -> String) =
        userNameGenerator(firstName, secondName)
}

Sie können diese Funktion verwenden, indem Sie ein Lambda übergeben. Da die Parameter bereits in der Funktionssignatur angegeben sind, müssen Sie sie nicht im Lambda-Ausdruck erneut deklarieren: 

val user = User("foo", "bar")
println(user.userName { firstName, secondName ->
     "${firstName.toUppercase}"_"${secondName.toUppercase}"
 }) // prints FOO_BAR

Dies gilt auch, wenn Sie einer Variablen ein Lambda zuweisen: 

//valid:
val addition: (Int, Int) = { a, b -> a + b }
//valid:
val addition = { a: Int, b: Int -> a + b }
//error (type inference failure):
val addition = { a, b -> a + b }

Wenn für das Lambda ein Parameter benötigt wird und der Typ aus dem Kontext abgeleitet werden kann, können Sie auf den Parameter durch it Bezug nehmen. 

listOf(1,2,3).map { it * 2 } // [2,4,6]

Lambda als Parameter für die Filterfunktion

val allowedUsers = users.filter { it.age > MINIMUM_AGE }

Lambda wurde als Variable übergeben

val isOfAllowedAge = { user: User -> user.age > MINIMUM_AGE }
val allowedUsers = users.filter(isOfAllowedAge)

Lambda für das Benchmarking eines Funktionsaufrufs

Mehrzweck-Stoppuhr für das Timing der Funktionsdauer einer Funktion: 

object Benchmark {
    fun realtime(body: () -> Unit): Duration {
        val start = Instant.now()
        try {
            body()
        } finally {
            val end = Instant.now()
            return Duration.between(start, end)
        }
    }
}

Verwendungszweck: 

val time = Benchmark.realtime({
    // some long-running code goes here ...
})
println("Executed the code in $time")


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow