Declaraciones de desestructuración con componentN
Desestructure instancias de clases de datos en variables mediante funciones component.
Declaraciones de desestructuración con componentN es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.
Conceptos básicos de la desestructuración
Una declaración de desestructuración descompone un objeto en varias variables en un solo paso. Utiliza las funciones operador componentN().
Desestructuración de una clase de datos
Las clases de datos generan automáticamente component1, component2, ... para que pueda escribir val (a, b) = obj.
data class Point(val x: Int, val y: Int)
fun main() {
val p = Point(3, 5)
val (x, y) = p
println("x=$x, y=$y")
}Desestructuración de un Pair
Los tipos de la biblioteca estándar Pair y Triple admiten la desestructuración de forma integrada.
fun main() {
val pair = "Ada" to 35
val (name, age) = pair
println("$name is $age")
}Desestructuración de un Triple
Triple contiene tres valores; desestructúrelo en tres variables.
fun main() {
val rgb = Triple(255, 128, 0)
val (r, g, b) = rgb
println("R=$r G=$g B=$b")
}Desestructuración al iterar un mapa
Las entradas de un mapa tienen component1 (clave) y component2 (valor). Desestructúrelas en la cabecera de un bucle for.
fun main() {
val ages = mapOf("Alice" to 30, "Bob" to 25)
for ((name, age) in ages) {
println("$name -> $age")
}
}Desestructuración en lambdas
Las lambdas que aceptan pares pueden desestructurar directamente sus parámetros.
fun main() {
val pairs = listOf("a" to 1, "b" to 2, "c" to 3)
pairs.forEach { (letter, num) -> println("$letter=$num") }
}Ignorar valores con _
Utilice el guion bajo _ para omitir los valores que no necesite.
data class User(val name: String, val email: String, val age: Int)
fun main() {
val u = User("Ada", "ada@example.com", 35)
val (name, _, age) = u
println("$name ($age)")
}Devolver varios valores
Una función puede devolver un Pair o una clase de datos personalizada; el código que la llama realiza la desestructuración.
data class Result(val sum: Int, val product: Int)
fun computeBoth(a: Int, b: Int) = Result(a + b, a * b)
fun main() {
val (s, p) = computeBoth(4, 5)
println("sum=$s product=$p")
}componentN personalizado
Cualquier clase puede admitir la desestructuración si declara operator fun componentN().
class RGB(val r: Int, val g: Int, val b: Int) {
operator fun component1() = r
operator fun component2() = g
operator fun component3() = b
}
fun main() {
val (red, green, blue) = RGB(255, 100, 0)
println("$red $green $blue")
}Desestructuración con withIndex()
Obtenga el índice y el valor como un par al iterar con withIndex().
fun main() {
val fruits = listOf("apple", "banana", "cherry")
for ((idx, fruit) in fruits.withIndex()) {
println("$idx: $fruit")
}
}Limitación: basada en la posición
La desestructuración se basa en la posición, no en el nombre. Reordenar los campos de una clase de datos cambia silenciosamente el significado en los puntos de llamada.
data class Point(val x: Int, val y: Int)
fun main() {
val p = Point(10, 20)
val (a, b) = p // a=x, b=y
// Add a property in the middle and old destructuring shifts!
println("$a $b")
}Comprobación rápida
¿Qué función operador permite desestructurar la propiedad i-ésima?
Resumen
La desestructuración utiliza funciones operador componentN(). Las clases de datos, Pair, Triple y las entradas de mapas la admiten de forma integrada. Utilice _ para omitir valores y tenga en cuenta que la desestructuración se basa en la posición, no en el nombre.
Preguntas frecuentes
¿La lección «Declaraciones de desestructuración con componentN» es gratis?
Sí — el texto completo de «Declaraciones de desestructuración con componentN» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Declaraciones de desestructuración con componentN»?
Desestructure instancias de clases de datos en variables mediante funciones component. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Kotlin Academy?
No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Declaraciones de desestructuración con componentN»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?
Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Fundamentos de las clases de datos: métodos generados automáticamente
- Copiar con copy() y sobrescrituras parciales
- Declaraciones de desestructuración con componentN
- Clases de datos en colecciones y como claves de mapas