Kotlin: làm thế nào để truyền một hàm làm tham số cho một hàm khác?

Cho hàm foo:

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

Chúng tôi có thể làm:

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

Bây giờ, giả sử chúng ta có chức năng sau:

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

Có cách nào để tôi có thể chuyển "buz" làm tham số cho "foo" không? Cái gì đó như:

foo("a message", buz)

Sử dụng ::để biểu thị một tham chiếu hàm, và sau đó:

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

Vì Kotlin 1.1, giờ đây bạn có thể sử dụng các hàm là thành viên của lớp (" Tham chiếu có thể gọi được giới hạn "), bằng cách thêm tiền tố vào toán tử tham chiếu hàm với ví dụ:

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

foo("hi", thatOtherThing::buz)

foo("hi", this::buz)

Về chức năng thành viên như tham số:

1. Lớp Kotlin không hỗ trợ chức năng thành viên tĩnh, vì vậy chức năng thành viên không thể được gọi như: Toán tử :: add (5, 4)
2. Do đó, chức năng thành viên không thể được sử dụng giống như chức năng hạng nhất.
3. Một cách tiếp cận hữu ích là bọc chức năng với lambda. Nó không thanh lịch nhưng ít nhất nó đang hoạt động.

mã:

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

sử dụng ::để tham khảo phương pháp.

giống

    foo(::buz) // calling buz here

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

Chỉ cần sử dụng "::" trước tên phương thức

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

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

foo(::bar) Đầu ra :Hello World

rõ ràng điều này chưa được hỗ trợ.

thêm thông tin:

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

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

Nếu bạn muốn vượt qua các phương thức setter và getter .

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

Sử dụng:

private var width: Int = 1

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

Câu trả lời của Jason Minard là một câu hỏi hay. Điều này cũng có thể đạt được bằng cách sử dụng a lambda.

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

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

Mà có thể được gọi với foo("a message", buz).

Bạn cũng có thể làm cho DRY thêm một chút bằng cách sử dụng a typealias.

typealias qux = (m: String) -> Unit

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

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

Một vi dụ khac:

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

Các chức năng hạng nhất hiện không được hỗ trợ trong Kotlin. Đã có tranh luận về việc liệu đây sẽ là một tính năng tốt để thêm vào. Cá nhân tôi nghĩ rằng họ nên.