Kotlin : comment passer une fonction en paramètre à une autre ?

Question

Fonction donnée foo :

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

Nous pouvons le faire :

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

Maintenant, disons que nous avons la fonction suivante :

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

Existe-t-il un moyen de passer "buz" comme paramètre à "foo" ? Quelque chose comme :

foo("a message", buz)

Answer 1

Utilisez :: pour signifier une référence de fonction, et ensuite :

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

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

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

Depuis Kotlin 1.1 vous pouvez maintenant utiliser des fonctions qui sont des membres de classe (" Références appelables liées "), en faisant précéder l'opérateur de référence de la fonction de l'instance :

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

foo("hi", thatOtherThing::buz)

foo("hi", this::buz)

Answer 2

A propos de la fonction membre comme paramètre :

1. La classe Kotlin ne supporte pas la fonction membre statique, donc la fonction membre ne peut pas être invoquée comme : Opérateur::add(5, 4)
2. Par conséquent, la fonction membre ne peut pas être utilisée de la même manière que la fonction de première classe.
3. Une approche utile consiste à envelopper la fonction avec un lambda. Ce n'est pas élégant, mais au moins cela fonctionne.

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 3

Utilisez simplement ": :" avant le nom de la méthode

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

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

foo(::bar) Sortie : Hello World

Answer 4

Kotlin 1.1

utiliser :: à la méthode de référence.

comme

    foo(::buz) // calling buz here

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

Answer 5

Si vous voulez passer setter y getter méthodes.

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

Utilisation :

private var width: Int = 1

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