Deconstrucción
Extraiga datos
Deconstrucción es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 4 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 Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué es la deconstrucción?
La deconstrucción (también llamada destructuring) consiste en extraer directamente las partes de una estructura de datos dentro de un patrón.
En lugar de llamar a métodos de acceso, describe la forma y nombra las partes que necesita.
Deconstruir una tupla
Una tupla agrupa varios valores. Puede separarlos en una sola vinculación escribiendo los nombres entre paréntesis.
object Main {
def main(args: Array[String]): Unit = {
val pair = ("Ada", 1815)
val (name, year) = pair
println(s"$name was born in $year")
}
}Tuplas en match
Puede deconstruir una tupla dentro de un match, asignando nombres a cada componente o haciéndolos coincidir.
object Main {
def quadrant(p: (Int, Int)): String = p match {
case (0, 0) => "origin"
case (x, 0) => s"on x-axis at $x"
case (0, y) => s"on y-axis at $y"
case (x, y) => s"point ($x, $y)"
}
def main(args: Array[String]): Unit = {
println(quadrant((0, 0)))
println(quadrant((3, 0)))
println(quadrant((2, 5)))
}
}Deconstruir la cabeza de una lista
El operador :: (cons) divide una lista en su primer elemento (la cabeza) y el resto (la cola).
El patrón head :: tail coincide con cualquier lista no vacía.
object Main {
def first(xs: List[Int]): String = xs match {
case head :: tail => s"head=$head, rest=$tail"
case Nil => "empty"
}
def main(args: Array[String]): Unit = {
println(first(List(10, 20, 30)))
println(first(Nil))
}
}Hacer coincidir formas exactas de listas
Puede hacer coincidir listas de una longitud específica enumerando sus elementos, como List(a, b) para exactamente dos elementos.
object Main {
def shape(xs: List[Int]): String = xs match {
case List() => "none"
case List(a) => s"one: $a"
case List(a, b) => s"two: $a, $b"
case _ => "many"
}
def main(args: Array[String]): Unit = {
println(shape(List()))
println(shape(List(1)))
println(shape(List(1, 2)))
println(shape(List(1, 2, 3)))
}
}Recursión con cabeza y cola
Separar la cabeza de la cola permite hacer una recursión clara sobre una lista.
Aquí sumamos una lista añadiendo la cabeza a la suma de la cola.
object Main {
def sum(xs: List[Int]): Int = xs match {
case Nil => 0
case head :: tail => head + sum(tail)
}
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3, 4)))
}
}Deconstruir estructuras anidadas
Los patrones pueden anidarse. Puede deconstruir una tupla dentro de una lista o una lista dentro de una tupla, todo a la vez.
object Main {
def main(args: Array[String]): Unit = {
val data = List(("a", 1), ("b", 2))
data match {
case (key, value) :: _ => println(s"first key=$key value=$value")
case Nil => println("empty")
}
}
}Ignorar partes con _
Use _ para los componentes que no le interesen. Así los patrones se centran en los datos que realmente necesita.
object Main {
def main(args: Array[String]): Unit = {
val triple = (1, 2, 3)
val (_, middle, _) = triple
println(s"middle = $middle")
}
}Vincular los dos primeros elementos y conservar el resto
Puede asignar nombres a los primeros elementos y capturar todo lo que queda con un patrón de cola.
object Main {
def main(args: Array[String]): Unit = {
val xs = List(1, 2, 3, 4, 5)
xs match {
case a :: b :: rest => println(s"a=$a b=$b rest=$rest")
case _ => println("too short")
}
}
}¿Por qué usar la deconstrucción?
La deconstrucción hace que el acceso a los datos sea:
- Declarativo: describe la forma, no los pasos
- Seguro: la estructura se comprueba al extraer los datos
- Conciso: vincula varios valores en un solo patrón
Resulta aún más potente con case classes.
Integración
Este ejemplo deconstruye una lista de tuplas y reacciona según su forma.
object Main {
def report(scores: List[(String, Int)]): String = scores match {
case Nil => "no scores"
case (name, pts) :: Nil => s"only $name with $pts"
case (name, pts) :: rest => s"top $name=$pts plus ${rest.size} more"
}
def main(args: Array[String]): Unit = {
println(report(Nil))
println(report(List(("Ann", 90))))
println(report(List(("Ann", 90), ("Bo", 80))))
}
}Comprobación rápida
Compruebe su comprensión de la deconstrucción.
Resumen
Ha aprendido a deconstruir datos en patrones:
- Las tuplas se separan con
(a, b) - Las listas se separan con
head :: tailo con formas exactas comoList(a, b) Nilcoincide con la lista vacía- Use
_para ignorar partes y anide patrones para estructuras profundas - Separar cabeza y cola permite hacer una recursión clara
Preguntas frecuentes
¿La lección «Deconstrucción» es gratis?
Sí — el texto completo de «Deconstrucción» 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 Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Deconstrucción»?
Extraiga datos Practicas Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming 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 4 de 4.
¿Cuánto tiempo toma la lección «Deconstrucción»?
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 Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming 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.