Pasar argumentos variables a una función en Kotlin

Hay muchos escenarios en los que necesitamos pasar argumentos variables a una función. En Kotlin, puedes pasar un número variable de argumentos a una función declarando la función con un parámetro vararg. un parámetro vararg de tipo T se representa internamente como una array de tipo T ( Array<T> ) dentro del cuerpo de la función. En este artículo, repasaremos todas las formas de hacerlo. Veremos algunos ejemplos para demostrar cómo usar esta característica de Kotlin.

Ejemplo

Sigamos los siguientes pasos, donde demostramos cómo pasar un número variable de argumentos a una función. Usando vararg, podemos pasar argumentos separados por comas a una función, donde hemos definido el único argumento de un método como vararg, como en el siguiente ejemplo:

fun main (args: Array<String>) {
  someMethod ( "as", "you", "know", "this", "works")
}
  
fun someMethod (vararg a: String) {
  for (a_ in a) {
    println(a_)
  }
}

Además, si ya tiene una array de valores, puede pasarla directamente usando el operador * spread:

fun main(args: Array<String>) {
   val list = arrayOf ("as", "you", "know", "this", "works")
   someMethod (*list)
}
  
fun someMethod (vararg a: String) {
  for (a_in a) {
    println(a_)
  }
}

Básicamente, vararg le dice al compilador que tome los argumentos pasados ​​y los envuelva en una array. El operador de extensión, por otro lado, simplemente le dice al compilador que desenvuelva los miembros de la array y los pase como argumentos separados. El operador de extensión, es decir, *, se coloca justo antes del nombre de la array que se pasa. Sin embargo, obviamente, uno siempre puede necesitar pasar otros argumentos, argumentos con nombre, etc. En el siguiente código de ejemplo, intentamos pasar otro argumento que no sea vararg:

fun main (args: Array<String>) {
  val list = arrayof( "as", "you", "know", "this", "works")
  someMethod ( 3, *list)
}
  
fun someMethod (b: Int, vararg a: String) {
  for (a_ in a) {
    println(a_)
  }
}

En el siguiente ejemplo, el primer argumento es similar al tipo vararg, pero funciona:

fun main (args: Array<String>) {
  someMethod ("3", "as", "you", "know", "this", "works")
}
  
fun someMethod (b: String, vararg a: String) {
  printIn ("b: " + b)
  for (a_ in a) {
       println (a_)
  }
}

Producción:

b: 3
as
you
know
this
works

Por lo general, vararg es el último argumento que se pasa, pero ¿qué pasa si queremos pasar otros argumentos después de vararg? Podemos, pero tienen que ser nombrados. Es por eso que el siguiente código no se compilará:

fun main (args: Array<String>) {
  someMethod ("3", "as", "you", "know", "this", "works", "what")
}
  
fun someMethod (b: String, vararg a: String, c: String) {
  printin ("b: " + b)
  for (a_ in a) {
    println(a_)
  }
  println("c: " + c)
}

No compila porque la última string pasada se considera parte de vararg, y el compilador arroja un error porque no pasamos el valor de c. Para hacerlo correctamente, necesitamos pasar c como un argumento con nombre, tal como se muestra aquí: 

fun main (args: Array<String>) {
  someMethod ("3", "as", "you", "know", "this", "works", c = "what")
}
  
fun someMethod (b: String, vararg a: String, c: String) {
  printin ("b: " + b)
  for (a_ in a){
    println(a_)
  }
  println ("c: " + c)
}

Producción:

b: 3
as
you
know
this
works
c:  what

El modificador vararg le dice al compilador que tome todos los argumentos separados por comas y los envuelva en una array, mientras que *, que es el operador de propagación, desenvuelve los elementos de la array y los pasa como argumentos.

¿Qué sucede si queremos que el primer argumento tenga un valor predeterminado, como en este ejemplo:

fun main (args: Array<String>) {
  someMethod ("3", "as", "you", "know", "this", "works")
}
  
fun someMethod (b: String = "x", vararg a: String) {
  printin ("b: " + b)
  for (a_ in a){
    println (a_)
  }
}

Queremos que todos los argumentos se consideren como parte de vararg, pero el compilador lee el primer argumento como b. En este caso, nombrar los argumentos pasados ​​puede resolver el problema:

fun main (args: Array<String>) {
  someMethod (a = *arrayOf ("3", "as", "you", "know", "this", "works"))
}
  
fun someMethod (b: String = "x", vararg a: String) {
  printin ("b: " + b)
  for (a in a){
    println (a_)
  }
}

En el código anterior, el compilador entiende que el valor de b no se pasa y toma el valor predeterminado. De manera similar, si desea tener dos vararg en su función, deberá pasar argumentos con nombre.