Operador de propagación de Kotlin

1. Generar un Proyecto Kotlin
2. Pasar múltiples argumentos en Kotlin
3. Pasar múltiples argumentos usando el operador de propagación en Kotlin
4. Pase múltiples argumentos usando matriz de tipos primitivos en Kotlin
5. Conclusión

El operador de propagación (*) se usa en la mayoría de los lenguajes de programación, como Kotlin, TypeScript, JavaScript y otros.

El operador de propagación se usa para pasar múltiples argumentos en lugares donde se espera más de un argumento. En Kotlin, el operador de propagación se puede usar con parámetros de función con el prefijo de la palabra clave vararg.

La palabra clave vararg indica que una función acepta un número variable de argumentos y puede usarse con tipos genéricos y no genéricos. Este tutorial le enseñará cómo funciona el operador de propagación y dónde se usa en Kotlin.

Generar un Proyecto Kotlin

Abra el entorno de desarrollo IntelliJ y seleccione Archivo > Nuevo > Proyecto. Ingrese el nombre del proyecto como kotlin-spread-operator, seleccione Kotlin en la sección Idioma y seleccione Intellij en la sección Build system.

Finalmente, presione el botón Crear para generar el proyecto. Una vez abierto el proyecto, cree un archivo llamado Main.kt en la carpeta src/main/kotlin y copie y pegue el siguiente código en el archivo.

class House(
    private val id: Int,
    private val houseType: String,
    private val houseLocation: String){

     companion object{
         fun <T> of(vararg houses: T): List<T>{
             val theHouses = ArrayList<T>();
             for (house in houses) {
                 theHouses.add(house);
             }
             return theHouses;
         }
     }

    fun getId(): Int{
        return this.id;
    }

    override fun toString(): String {
        return "House(id=$id, houseType='$houseType', houseLocation='$houseLocation')"
    }

}

En este código, hemos creado una clase llamada House con las propiedades id, houseType y houseLocation que deben proporcionarse al crear un objeto.

También hemos definido tres métodos llamados of(), getId() y toString(). El método of() se define dentro de un objeto complementario para indicar que es un método estático que se puede invocar sin crear ningún objeto.

El método getId() devuelve el id del objeto actual, y el método toString() nos ayuda a obtener una representación de cadena de nuestro objeto. Usaremos esta clase en las próximas secciones para crear instancias que usaremos en nuestros ejemplos.

Pasar múltiples argumentos en Kotlin

Copie y pegue el siguiente código en el archivo Main.kt después de la declaración de clase House.

fun multipleArgumentFunction(){
    val bungalow = House(1,"Bungalow","Seattle");
    val flat = House(2,"Flat","Texas")
    val houses: List<House> = House.of(bungalow, flat);
    houses.forEach(::println);
}

fun main(){
    multipleArgumentFunction();
}

En este código, hemos creado un método que crea dos objetos de casa y devuelve una lista de estos objetos pasándolos como argumentos del método of().

Quizás se pregunte por qué pasamos dos argumentos mientras proporcionamos un parámetro al definir el método estático of(). Recuerda que mencionamos un método que podría aceptar más de un argumento si tiene la palabra clave vararg.

Tenga en cuenta que el método estático of() tiene la palabra clave vararg y, por lo tanto, puede aceptar más de un argumento. Ejecute este código y asegúrese de que el resultado sea como se muestra a continuación.

House(id=1, houseType='Bungalow', houseLocation='Seattle')
House(id=2, houseType='Flat', houseLocation='Texas')

Pasar múltiples argumentos usando el operador de propagación en Kotlin

Hemos mencionado que un operador de distribución se usa para pasar múltiples argumentos donde se espera más de un argumento, y un operador de distribución generalmente se indica usando el operador *, que generalmente tiene el prefijo en el objeto que contiene la matriz de datos.

Comente el código anterior y copie y pegue el siguiente código en el archivo Main.kt después del comentario.

fun multipleArgumentFunctionWithSpreadOperator(){
    val bungalow = House(1,"Bungalow","Seattle");
    val flat = House(2,"Flat","Texas")

    val apartments: Array<House> = arrayOf(
        House(3,"Apartment","San Francisco"),
        House(4,"Apartment","New York"),
        House(5,"Apartment","Florida")
    );

    val theHouses: List<House> = House.of(bungalow, flat, *apartments);
    theHouses.forEach(::println);
}

fun main(){
    multipleArgumentFunctionWithSpreadOperator();
}

Este ejemplo se basa en el ejemplo anterior, y en este código, hemos agregado un Array que contiene tres objetos de casa.

El método of() nos permite pasar un número variable de argumentos; pasamos esta matriz al método usando el operador de propagación.

Tenga en cuenta que también puede pasar otros objetos individuales al método.

Usamos la sintaxis *apartamentos para pasar la matriz al método, y todos los objetos de la matriz están disponibles para el código dentro del método. Ejecute el siguiente código y asegúrese de que el resultado sea como se muestra a continuación.

House(id=1, houseType='Bungalow', houseLocation='Seattle')
House(id=2, houseType='Flat', houseLocation='Texas')
House(id=3, houseType='Apartment', houseLocation='San Francisco')
House(id=4, houseType='Apartment', houseLocation='New York')
House(id=5, houseType='Apartment', houseLocation='Florida')

Pase múltiples argumentos usando matriz de tipos primitivos en Kotlin

Kotlin proporciona arreglos de tipos primitivos que incluyen IntArray, ShortArray, ByteArray, LongArray y otros.

Si usamos estos tipos en nuestra aplicación, somos propensos a obtener errores de Error de coincidencia de tipos, y este ejemplo muestra cómo resolver esto.

Comente el código anterior y copie y pegue el siguiente código en el archivo Main.kt después del comentario.

fun multipleArgumentFunctionWithTypedArray(){
    val bungalow = House(1,"Bungalow","Seattle");
    val flat = House(2,"Flat","Texas")

    val apartments: Array<House> = arrayOf(
        House(3,"Apartment","San Francisco"),
        House(4,"Apartment","New York"),
        House(5,"Apartment","Florida")
    );

    val apartmentCount: IntArray =
        apartments.map(House::getId).toIntArray();

    val totalHouses: List<Int> =
        House.of(bungalow.getId(),flat.getId(), *apartmentCount.toTypedArray());

    totalHouses.forEach(::println);
}

fun main(){
    multipleArgumentFunctionWithTypedArray();
}

En este ejemplo, nuestro objetivo es devolver todos los id pasados al método of() como una colección de enteros List<Int>.

El método map() usa el arreglo de objetos casa Array<House> para devolver el arreglo de tipo primitivo IntArray usando el método toIntArray().

Para devolver todos los id de nuestros objetos, hemos pasado los id de los objetos individuales al método of() usando el método getId().

Hemos pasado el objeto restante id al método of() utilizando un operador de propagación. Sin embargo, primero convertimos la matriz de tipo primitivo IntArray en una matriz de tipo normal Array<Int> usando el método toTypedArray() para evitar el error de Error de coincidencia de tipos.

Ejecute este código y asegúrese de que el resultado sea como se muestra a continuación.

1
2
3
4
5

Conclusión

En este tutorial, hemos aprendido cómo usar el operador de distribución en Kotlin, y los temas que hemos cubierto incluyen cómo pasar múltiples argumentos usando el operador de distribución y cómo pasar múltiples argumentos usando el operador de distribución. Finalmente, cubrimos cómo pasar múltiples argumentos usando una matriz de tipo primitivo.