syntax - new - Operador de asterisco de Kotlin antes del nombre de variable u Operador de propagación en Kotlin

subclass kotlin

Question

Quiero saber qué hace exactamente el asterisco antes del nombre de la variable en Kotlin. Vi esto ( *args ) en el ejemplo de Spring boot Kotlin :

@SpringBootApplication
open class Application {

    @Bean
    open fun init(repository: CustomerRepository) = CommandLineRunner {
        repository.save(Customer("Jack", "Bauer"))
        repository.save(Customer("Chloe", "O''Brian"))
        repository.save(Customer("Kim", "Bauer"))
        repository.save(Customer("David", "Palmer"))
        repository.save(Customer("Michelle", "Dessler"))
    }
}

fun main(args: Array<String>) {
    SpringApplication.run(Application::class.java, *args)
}

Answer 1

Además de las respuestas que se dirigieron directamente a "¡¿Qué es esto?!", A menudo tiene el caso de que tiene una List y desea pasarla a una función que espera un vararg . Para esto, la conversión es:

someFunc(x, y, *myList.toTypedArray())

Suponiendo que el último parámetro de someFunc es un vararg del mismo tipo que los elementos de la lista.

Answer 2

Como se describe en la documentación, este es un operador de propagación:

Cuando llamamos a una función vararg, podemos pasar 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, usamos el spread operador (prefijo la matriz con *):

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

Answer 3

El operador * se conoce como Operador de propagación en Kotlin.

De la referencia de Kotlin ...

Cuando llamamos a una función vararg, podemos pasar 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, usamos el spread operador (prefijo la matriz con *):

Se puede aplicar a una matriz antes de pasarla a una función que acepte varargs .

Por ejemplo...

Si tiene una función que acepta un número variado de argumentos ...

fun sumOfNumbers(vararg numbers: Int): Int {
    return numbers.sum()
}

Puedes pasarle una matriz así ...

val numbers = intArrayOf(2, 3, 4)
val sum = sumOfNumbers(*numbers)
println(sum) // Prints ''9''

Notas:

• El operador * también es el operador de multiplicación (por supuesto).
• El operador solo se puede usar al pasar argumentos a una función. El resultado de la operación no puede almacenarse ya que no produce ningún valor (es azúcar puramente sintáctico).
• Al principio, el operador puede confundir a algunos programadores de C / C ++ porque parece que un puntero está siendo desreferenciado. No lo es; Kotlin no tiene noción de punteros .
• El operador se puede usar entre otros argumentos al llamar a una función vararg. Esto se demuestra en el ejemplo aquí .
• El operador es similar a la función de apply en varios lenguajes de programación funcionales.

Answer 4

En Java, puede pasar una matriz tal cual, pero una ventaja de desempacar una matriz con el operador extendido * es que el operador extendido le permite combinar los valores de una matriz y algunos valores fijos en una sola llamada. Java no es compatible con esto.

Answer 5

Si una función que acepta un parámetro vararg (número variable de argumentos) como:

fun sum(vararg data:Int)
{
   // function body here         
}

Ahora para llamar a este método, podemos hacer:

sum(1,2,3,4,5)

Pero, ¿qué pasa si tenemos estos valores en una matriz, como:

val array= intArrayOf(1,2,3,4,5)

entonces, para llamar a este método, tenemos que usar el operador spread, como:

 sum(*array)

Aquí, * (operador de propagación) pasará todo el contenido de esa matriz.

* matriz es equivalente a 1,2,3,4,5

Pero espere un minuto, ¿y si lo llamamos así: sum(array) nos dará un error de tiempo de compilación de tipo no coincidente:

Type mismatch.
Required:Int
Found:IntArray

El problema es que la función de sum acepta un parámetro vararg Int (que acepta valores como: 1,2,3,4,5) y si pasamos la matriz, se pasará como IntArray .