Kotlin: Wie übergibt man eine Funktion als Parameter an einen anderen?

Question

Gegeben Funktion foo:

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

Wir tun können:

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

wir nun an, wir die folgende Funktion haben:

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

Gibt es eine Möglichkeit, ich Buz passieren kann“ "Als Parameter für" foo "? Etwas wie:

foo("a message", buz) 

Answer 1

Verwenden :: eine Funktionsreferenz, um anzuzeigen, 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) 
} 

Since Kotlin 1.1 Sie jetzt Funktionen verwenden können, die Klassenmitglieder sind ("Gebundene anrufbare Referenzen „), die von der Funktion Referenzoperator mit der Instanz Vorfixierung:

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

foo("hi", thatOtherThing::buz) 

foo("hi", this::buz) 

Answer 2

First-Class-Funktionen sind derzeit nicht in Kotlin unterstützt. Es gab Diskussionen darüber, ob dies ein gutes Feature wäre. Ich persönlich denke, sie sollten es tun.

Answer 3

anscheinend wird dies noch nicht unterstützt.

weitere Informationen:

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

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

Answer 4

Über die Elementfunktion als Parameter:

1. Kotlin Klasse nicht statische Elementfunktion, so dass die Elementfunktion unterstützt kann‘ t aufgerufen werden wie: Operator :: hinzufügen (5, 4)
2. Daher kann die Member-Funktion nicht so wie die First-Class-Funktion verwendet werden.
3. Ein nützlicher Ansatz besteht darin, die Funktion mit einem Lambda zu umhüllen. Es ist nicht elegant, aber zumindest funktioniert es.

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

Answer 5

Verwenden Sie einfach "::" vor Methodennamen als Parameter

fun main(args: Array<String>) { 
    runAFunc(::runLines) 
} 


fun runAFunc(predicate: (Int) -> (Unit)) { 
    val a = "five" 
    if (a == "five") predicate.invoke(5) else predicate.invoke(3) 

} 

fun runLines(numbers: Int) { 
    var i = numbers 
    while (i > 0) { 
     println("printed number is $i") 
     i-- 
    } 
} 

Answer 6

Kotlin 1.1

dieses :: Buz (wenn in gleiche Klasse) oder Klasse() :: buz, falls unterschiedlich