function - pass - Kotlin: ¿Puedes usar argumentos con nombre para varargs?

when in kotlin android

Question

Por ejemplo, podría tener una función con una firma complicada y varargs:

fun complicated(easy: Boolean = false, hard: Boolean = true, vararg numbers: Int)

Tendría sentido que pudieras llamar a esta función así:

complicated(numbers = 1, 2, 3, 4, 5)

Desafortunadamente el compilador no permite esto.

¿Es posible usar argumentos con nombre para varargs? ¿Hay soluciones inteligentes?

Answer 1

El parámetro vararg puede estar en cualquier parte de la lista de parámetros. Vea el siguiente ejemplo de cómo se puede llamar con diferentes conjuntos de parámetros. Por cierto, cualquier llamada también puede proporcionar lambda después de un paréntesis cerrado.

fun varargs(
first: Double = 0.0,
second: String = "2nd",
vararg varargs: Int,
third: String = "3rd",
lambda: ()->Unit = {}
) {
...
}
fun main(args: Array<String>) {
val list = intArrayOf(1, 2, 3)
varargs(1.0, "...", *list, third="third")
varargs(1.0, "...", *list)
varargs(1.0, varargs= *list, third="third")
varargs(varargs= *list, third="third")
varargs(varargs= *list, third="third", second="...")
varargs(varargs= *list, second="...")
varargs(1.0, "...", 1, 2, 3, third="third")
varargs(1.0, "...", 1, 2, 3)
varargs(1.0)
varargs(1.0, "...", third="third")
varargs(1.0, third="third")
varargs(third="third")
}

Answer 2

Kotlin Docs dice claramente que:

Número variable de argumentos (Varargs)

Un parámetro de una función (normalmente la última) puede marcarse con vararg modificador vararg :

fun <T> asList(vararg ts: T): List<T> {
val result = ArrayList<T>()
for (t in ts) // ts is an Array
result.add(t)
return result
}

permitiendo que se pase un número variable de argumentos a la función:

 val list = asList(1, 2, 3)

Dentro de una función, un vararg de tipo T es visible como una matriz de T , es decir, la variable ts en el ejemplo anterior tiene el tipo Array<out T> .

Solo se puede marcar un parámetro como vararg . Si un parámetro vararg no es el último en la lista, se pueden pasar valores para los siguientes parámetros utilizando la sintaxis del argumento nombrado o, si el parámetro tiene un tipo de función, pasando una lambda fuera de paréntesis.

Cuando llamamos una vararg vararg, podemos pasar los argumentos uno por uno, por ejemplo, asList(1, 2, 3) , o, si ya tenemos una matriz y queremos pasar su contenido a la función, utilizamos la propagación operador (prefije la matriz con * ):

val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)

De: https://kotlinlang.org/docs/reference/functions.html#variable-number-of-arguments-varargs

Para reanudar, puedes hacerlo usando el operador de propagación para que se vea como:

complicated(numbers = *intArrayOf(1, 2, 3, 4, 5))

Espero que ayude

Answer 3

Para pasar un argumento con nombre a un parámetro vararg, use el operador de propagación :

complicated(numbers = *intArrayOf(1, 2, 3, 4, 5))

Answer 4

Se puede vararg moviendo argumentos opcionales después del vararg :

fun complicated(vararg numbers: Int, easy: Boolean = false, hard: Boolean = true) = {}

Entonces se puede llamar así:

complicated(1, 2, 3, 4, 5)
complicated(1, 2, 3, hard = true)
complicated(1, easy = true)

Tenga en cuenta que los parámetros opcionales finales se deben pasar siempre con nombre. Esto no compilará:

complicated(1, 2, 3, 4, true, true) // compile error

Otra opción es ahorrar azúcar vararg para un vararg explícito de la matriz:

fun complicated(easy: Boolean = false, hard: Boolean = true, numbers: IntArray) = {}
complicated(numbers = intArrayOf(1, 2, 3, 4, 5))