Decomposizione
Estrarre dai dati
Decomposizione è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Che cos'è la decostruzione?
La decostruzione (chiamata anche destructuring) consiste nell'estrarre direttamente le parti di una struttura dati all'interno di un pattern.
Anziché chiamare metodi accessor, si descrive la forma e si assegnano nomi alle parti desiderate.
Decostruire una tupla
Una tupla raggruppa diversi valori. È possibile separarli in un'unica associazione scrivendo i nomi tra parentesi.
object Main {
def main(args: Array[String]): Unit = {
val pair = ("Ada", 1815)
val (name, year) = pair
println(s"$name was born in $year")
}
}Tuple in match
È possibile decostruire una tupla all'interno di un match, assegnando un nome o confrontando ciascun componente.
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)))
}
}Decostruire la testa di una lista
L'operatore :: (cons) divide una lista nel primo elemento (testa) e nel resto (coda).
Il pattern head :: tail corrisponde a qualsiasi lista non vuota.
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))
}
}Confrontare forme esatte di liste
È possibile confrontare liste di una lunghezza specifica elencandone gli elementi, come List(a, b) per una lista di esattamente due elementi.
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)))
}
}Ricorsione con testa e coda
Separare la testa dalla coda consente di eseguire una ricorsione ordinata su una lista.
Qui si sommano gli elementi di una lista aggiungendo la testa alla somma della coda.
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)))
}
}Decostruire strutture annidate
I pattern possono essere annidati. È possibile decostruire contemporaneamente una tupla all'interno di una lista o una lista all'interno di una tupla.
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")
}
}
}Ignorare parti con _
Usi _ per i componenti che non interessano. In questo modo i pattern si concentrano sui dati effettivamente necessari.
object Main {
def main(args: Array[String]): Unit = {
val triple = (1, 2, 3)
val (_, middle, _) = triple
println(s"middle = $middle")
}
}Associare i primi due elementi e conservare il resto
È possibile assegnare un nome ai primi elementi e acquisire tutto ciò che segue con un pattern di coda.
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")
}
}
}Perché usare la decostruzione?
La decostruzione rende l'accesso ai dati:
- dichiarativo: descrive la forma, non i passaggi
- sicuro: la struttura viene verificata durante l'estrazione
- conciso: associa più valori in un unico pattern
Diventa ancora più potente con le case class.
Mettere tutto insieme
Questo esempio decostruisce una lista di tuple e reagisce alla 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))))
}
}Verifica rapida
Verifichi la Sua comprensione della decostruzione.
Riepilogo
Ha imparato a decostruire i dati nei pattern:
- le tuple si separano con
(a, b) - le liste si separano con
head :: tailo con forme esatte comeList(a, b) Nilcorrisponde alla lista vuota- usi
_per ignorare parti e annidi i pattern per le strutture profonde - la separazione tra testa e coda consente una ricorsione ordinata
Domande Frequenti
La lezione «Decomposizione» è gratuita?
Sì — il testo completo di «Decomposizione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Decomposizione»?
Estrarre dai dati Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Decomposizione»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.