Destrucción de declaraciones en Kotlin

Kotlin proporciona al programador una forma única de trabajar con instancias de una clase, en forma de declaraciones de desestructuración . Una declaración de desestructuración es la que crea e inicializa múltiples variables a la vez.
Por ejemplo :

val (emp_id,salary) = employee

Estas múltiples variables corresponden a las propiedades de una clase que están asociadas a una instancia. Estas variables se pueden utilizar de forma independiente en la forma que desee.

println(emp_id+" "+salary)

La declaración de destrucción funciona con el concepto de funciones de componente() . El número de variables que puede definir una declaración de destrucción, la clase proporciona ese número de funciones de componente, comenzando desde componente1(), componente2() hasta componenteN(). La clase de datos en Kotlin por defecto implementa funciones de componentes.

Declaración de desestructuración compilada en el siguiente código: –

val emp_id = employee.component1()
val salary = employee.component2()

Programa Kotlin para devolver dos valores de una función:

// A sample data class
data class Data(val name:String,val age:Int)
   
// A function returning two values
fun sendData():Data{
    return Data("Jack",30)
}
   
fun main(){
    val obj = sendData()
    //  Using instance to access properties
    println("Name is ${obj.name}")
    println("Age is ${obj.age}")
   
    // Creating two variables using  destructing declaration
    val (name,age) = sendData()
    println("Name is $name")
    println("Age is $age")
   
}

Producción:

El nombre es Jack La
edad es 30
El nombre es Jack La
edad es 30

Nota: Las definiciones de las funciones de los componentes deben estar precedidas por la palabra clave operator si se van a utilizar en una declaración de desestructuración.

Guión bajo para variables no utilizadas
A veces, es posible que desee ignorar una variable en una declaración de desestructuración. Para hacerlo, coloque un guión bajo en lugar de su nombre. En este caso, no se invoca la función componente para la variable dada.

Declaración de desestructuración en lambdas –

Tras la llegada de Kotlin 1.1 , la sintaxis de declaración de destrucción también se puede usar para parámetros lambda . Si un parámetro lambda tiene un parámetro de tipo Par o algún otro tipo que declara funciones de componentes, entonces podemos introducir nuevos parámetros poniéndolos entre paréntesis. Las reglas son las mismas definidas anteriormente.

Programa Kotlin de uso de declaración de desestructuración para parámetros lambda –

fun main(){
    val map = mutableMapOf<Int,String>()
    map.put(1,"Ishita")
    map.put(2,"Kamal")
    map.put(3,"Kanika")
    map.put(4,"Minal")
    map.put(5,"Neha")
    map.put(6,"Pratyush")
    map.put(7,"Shagun")
    map.put(8,"Shashank")
    map.put(9,"Uday")
    map.put(10,"Vandit")
    println("Initial map is")
    println(map)
    // Destructuring a map entry into key and values
    val newmap = map.mapValues { (key,value) -> "Hello ${value}" }
    println("Map after appending Hello")
    println(newmap)
}

Producción:

El mapa inicial es
{1=Ishita, 2=Kamal, 3=Kanika, 4=Minal, 5=Neha, 6=Pratyush, 7=Shagun, 8=Shashank, 9=Uday, 10=Vandit}
Mapa después de agregar Hola
{1 =Hola Ishita, 2=Hola Kamal, 3=Hola Kanika, 4=Hola Minal, 5=Hola Neha, 6=Hola Pratyush, 7=Hola Shagun, 8=Hola Shashank, 9=Hola Uday, 10=Hola Vandit}

Si un componente del parámetro desestructurado no está en uso, podemos reemplazarlo con el guión bajo para evitar llamar a la función del componente:

map.mapValues { (_,value) -> "${value}" }