Kotlin: จะส่งฟังก์ชันเป็นพารามิเตอร์ไปยังอีกฟังก์ชันหนึ่งได้อย่างไร

ให้ฟังก์ชัน foo:

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

เราสามารถทำได้:

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

ตอนนี้สมมติว่าเรามีฟังก์ชันต่อไปนี้:

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

มีวิธีส่ง "buz" เป็นพารามิเตอร์ไปยัง "foo" ได้อย่างไร สิ่งที่ต้องการ:

foo("a message", buz)

ใช้::เพื่อแสดงการอ้างอิงฟังก์ชันจากนั้น:

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

เนื่องจาก Kotlin 1.1คุณสามารถใช้ฟังก์ชันที่เป็นสมาชิกคลาสได้แล้ว (" Bound Callable References ") โดยนำหน้าตัวดำเนินการอ้างอิงฟังก์ชันด้วยอินสแตนซ์:

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

foo("hi", thatOtherThing::buz)

foo("hi", this::buz)

เกี่ยวกับฟังก์ชันสมาชิกเป็นพารามิเตอร์:

1. คลาส Kotlin ไม่รองรับฟังก์ชันสมาชิกแบบคงที่ดังนั้นจึงไม่สามารถเรียกใช้ฟังก์ชันสมาชิกได้เช่น: Operator :: add (5, 4)
2. ดังนั้นจึงไม่สามารถใช้ฟังก์ชันสมาชิกเหมือนกับฟังก์ชันชั้นหนึ่งได้
3. วิธีการที่มีประโยชน์คือการรวมฟังก์ชันด้วยแลมด้า ไม่สวยหรู แต่อย่างน้อยก็ใช้งานได้

รหัส:

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

เพียงใช้ "::" ก่อนชื่อเมธอด

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

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

foo(::bar) เอาท์พุต :Hello World

Kotlin 1.1

ใช้::อ้างอิงวิธีการ

ชอบ

    foo(::buz) // calling buz here

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

หากคุณต้องการผ่านวิธีการsetterและgetter

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

การใช้งาน:

private var width: Int = 1

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

เห็นได้ชัดว่าสิ่งนี้ยังไม่รองรับ

ข้อมูลเพิ่มเติม:

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

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

คำตอบของ Jason Minard นั้นดี สิ่งนี้สามารถทำได้โดยใช้ไฟล์lambda.

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

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

foo("a message", buz)ซึ่งสามารถที่จะเรียกว่ามี

คุณยังสามารถทำให้แห้งมากขึ้นอีกเล็กน้อยโดยใช้ไฟล์ typealias .

typealias qux = (m: String) -> Unit

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

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

ตัวอย่างอื่น:

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

คุณยังสามารถทำอินไลน์ได้โดยใช้แลมบ์ดาหากนั่นคือที่เดียวที่คุณใช้ฟังก์ชันนั้น

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

foo("a message") {
    m: String -> println("another message: $m")
}
//Outputs: another message: a message

ขณะนี้ Kotlin ยังไม่รองรับฟังก์ชันชั้นหนึ่ง มีการถกเถียงกันว่านี่จะเป็นคุณสมบัติที่ดีที่จะเพิ่มหรือไม่ ส่วนตัวคิดว่าควร