Ricerca…


Sintassi

  • Parametri espliciti:

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

  • Parametri dedotti:

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

  • Singolo parametro it stenografia

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

  • Firma:

  • () -> ResultType

  • (InputType) -> ResultType

  • (InputType1, InputType2) -> ResultType

Osservazioni

I parametri del tipo di input possono essere omessi quando possono essere omessi quando possono essere dedotti dal contesto. Ad esempio, diciamo che hai una funzione su una classe che accetta una funzione:

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

È possibile utilizzare questa funzione passando un lambda e poiché i parametri sono già specificati nella firma della funzione non è necessario ripeterli nuovamente nell'espressione lambda:

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

Questo vale anche quando assegni un lambda a una variabile:

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

Quando lambda accetta un parametro e il tipo può essere dedotto dal contesto, puoi fare riferimento al parametro it .

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

Lambda come parametro per filtrare la funzione

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

Lambda è passato come una variabile

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

Lambda per il benchmarking di una chiamata di funzione

Cronometro per uso generico per la tempistica della durata di una funzione da eseguire:

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

Uso:

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
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow