Kotlin: Wie übergebe ich eine Funktion als Parameter an eine andere?

Gegebene Funktion foo:

fun foo(m: String, bar: (m: String) -> Unit) {
    bar(m)
}

Wir können tun:

foo("a message", { println("this is a message: $it") } )
//or 
foo("a message")  { println("this is a message: $it") }

Nehmen wir nun an, wir haben die folgende Funktion:

fun buz(m: String) {
   println("another message: $m")
}

Gibt es eine Möglichkeit, "buz" als Parameter an "foo" zu übergeben? Etwas wie:

foo("a message", buz)

Verwenden Sie ::diese Option, um eine Funktionsreferenz zu kennzeichnen, und dann:

fun foo(m: String, bar: (m: String) -> Unit) {
    bar(m)
}

// my function to pass into the other
fun buz(m: String) {
    println("another message: $m")
}

// someone passing buz into foo
fun something() {
    foo("hi", ::buz)
}

Seit Kotlin 1.1 können Sie jetzt Funktionen verwenden, die Klassenmitglieder sind (" Bound Callable References "), indem Sie dem Funktionsreferenzoperator die Instanz voranstellen :

foo("hi", OtherClass()::buz)

foo("hi", thatOtherThing::buz)

foo("hi", this::buz)

Informationen zur Elementfunktion als Parameter:

1. Die Kotlin-Klasse unterstützt keine statische Elementfunktion, daher kann die Elementfunktion nicht wie folgt aufgerufen werden: Operator :: add (5, 4)
2. Daher kann die Member-Funktion nicht wie die First-Class-Funktion verwendet werden.
3. Ein nützlicher Ansatz besteht darin, die Funktion mit einem Lambda zu versehen. Es ist nicht elegant, aber es funktioniert zumindest.

Code:

class Operator {
    fun add(a: Int, b: Int) = a + b
    fun inc(a: Int) = a + 1
}

fun calc(a: Int, b: Int, opr: (Int, Int) -> Int) = opr(a, b)
fun calc(a: Int, opr: (Int) -> Int) = opr(a)

fun main(args: Array<String>) {
    calc(1, 2, { a, b -> Operator().add(a, b) })
    calc(1, { Operator().inc(it) })
}

Kotlin 1.1

verwenden , ::um Referenzmethode.

mögen

    foo(::buz) // calling buz here

    fun buz() {
        println("i am called")
    }

Verwenden Sie einfach "::" vor dem Methodennamen

fun foo(function: () -> (Unit)) {
   function()
}

fun bar() {
    println("Hello World")
}

foo(::bar) Ausgabe :Hello World

anscheinend wird dies noch nicht unterstützt.

Mehr Info:

http://devnet.jetbrains.com/message/5485180#5485180

http://youtrack.jetbrains.com/issue/KT-1183

Wenn Sie Setter- und Getter- Methoden übergeben möchten .

private fun setData(setValue: (Int) -> Unit, getValue: () -> (Int)) {
    val oldValue = getValue()
    val newValue = oldValue * 2
    setValue(newValue)
}

Verwendung:

private var width: Int = 1

setData({ width = it }, { width })

Jason Minards Antwort ist gut. Dies könnte auch mit a erreicht werden lambda.

fun foo(m: String, bar: (m: String) -> Unit) {
    bar(m)
}

val buz = { m: String ->
    println("another message: $m")
}

Welches kann mit aufgerufen werden foo("a message", buz).

Sie können dies auch etwas trockener machen, indem Sie a verwenden typealias.

typealias qux = (m: String) -> Unit

fun foo(m: String, bar: qux) {
    bar(m)
}

val buz: qux = { m ->
    println("another message: $m")
}

Ein anderes Beispiel:

 fun foo(x:Int, Multiply: (Int) -> (Int)) {
    println(Multiply(x))
 }
 fun bar(x:Int):Int{
    return  x * x
 }
 foo(10, ::bar)

Erstklassige Funktionen werden derzeit in Kotlin nicht unterstützt. Es gab Debatten darüber, ob dies eine gute Funktion wäre. Ich persönlich denke, sie sollten.