0Pricing
Scala for Backend Engineering & Functional Programming · Lezione

Destrutturare tuple

Estragga nuovamente i valori.

Destrutturare tuple è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 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.

Estrarre i valori

Creare una tupla è solo metà del lavoro. Per usare i valori al suo interno, è necessario estrarli.

Scala offre due modalità principali: gli accessor numerati e il destructuring tramite pattern. Questa lezione tratta entrambi.

Accedere per posizione

Ogni elemento della tupla ha una posizione, leggibile con ._1, ._2 e così via.

Noti che le posizioni iniziano da uno, non da zero. Quindi ._1 è il primo elemento.

val person = ("Alice", 30)
println(person._1)
println(person._2)

Usare gli accessor nel codice

Gli accessor posizionali sono utili quando serve un solo elemento.

Qui leggiamo l'età da una coppia e vi aggiungiamo uno. Gli accessor restituiscono il tipo originale dell'elemento, quindi è possibile eseguire direttamente operazioni matematiche.

val record = ("Bob", 42)
val nextYear = record._2 + 1
println(nextYear)

Destructuring con val

Leggere ._1 e ._2 può rendere il codice difficile da seguire. Il destructuring consente di assegnare un nome a ogni elemento contemporaneamente.

Questo pattern val associa name e age in una sola riga.

val (name, age) = ("Cara", 25)
println(name)
println(age)

Perché il destructuring è utile

Le variabili con nome sono molto più leggibili delle posizioni numerate.

Rispetto al confronto tra age e person._2, la versione con destructuring rende evidente l'intento ed evita errori di tipo off-by-one.

val (city, population) = ("Lyon", 500000)
println(s"$city has $population people")

Destructuring di tre elementi

Il destructuring funziona con tuple di qualsiasi dimensione, non solo con le coppie.

Qui una tupla di tre elementi viene scomposta in tre variabili con nome in una sola istruzione.

val (id, label, active) = (7, "task", true)
println(id)
println(label)
println(active)

Ignorare con il carattere di sottolineatura

A volte servono solo alcuni valori. Usi un carattere di sottolineatura _ per saltare una posizione.

Qui conserviamo solo il nome e ignoriamo completamente l'età.

val (name, _) = ("Dana", 40)
println(name)

Destructuring dei risultati di una funzione

Le funzioni che restituiscono tuple si combinano naturalmente con il destructuring.

Può assegnare un nome a entrambi i valori restituiti direttamente nel punto in cui chiama la funzione, rendendo il risultato autoesplicativo.

def minMax(a: Int, b: Int) = (a min b, a max b)
val (low, high) = minMax(8, 3)
println(low)
println(high)

Scambiare una coppia

Una tupla di due elementi dispone di un metodo swap integrato che scambia i suoi elementi.

Il metodo restituisce una nuova coppia con l'ordine invertito, cosa che può risultare utile in alcuni casi.

val pair = ("a", 1)
println(pair.swap)

Destructuring in for

Quando si scorre una collezione di coppie, è possibile usare il destructuring nell'intestazione del ciclo.

A ogni iterazione, ogni coppia viene scomposta automaticamente in key e value.

val pairs = List(("a", 1), ("b", 2))
for ((key, value) <- pairs) println(s"$key=$value")

I tipi vengono preservati

Il destructuring non perde mai le informazioni sui tipi. Ogni variabile con nome conserva il tipo esatto della propria posizione.

Quindi, in val (n, age) = ("Eve", 33), n è una String e age è un Int, pronti per un uso type-safe.

val (n, age) = ("Eve", 33)
println(n.length)
println(age * 2)

Verifica rapida

Verifichi ciò che ha imparato sul destructuring delle tuple.

Riepilogo

Può estrarre i valori di una tupla con accessor posizionali come ._1 (a partire da uno) oppure, in modo più chiaro, con il destructuring, ad esempio val (a, b) = pair.

Il carattere di sottolineatura salta le posizioni non necessarie, il destructuring funziona nei cicli for e i tipi vengono sempre preservati. Ora esplorerà gli intervalli.

Domande Frequenti

La lezione «Destrutturare tuple» è gratuita?

Sì — il testo completo di «Destrutturare tuple» è 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 «Destrutturare tuple»?

Estragga nuovamente i valori. 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 2 di 4.

Quanto tempo richiede la lezione «Destrutturare tuple»?

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.

Tutte le lezioni di questo corso

  1. Creare tuple
  2. Destrutturare tuple
  3. Costruire intervalli
  4. Intervalli nei cicli
← Torna a Scala for Backend Engineering & Functional Programming