Destructuring declaration — cos'è, sintassi e utilizzo in Kotlin

Cos'è destructuring declaration?

Destructuring declaration (dichiarazione di destrutturazione) è una costruzione sintattica di Kotlin che consente di scomporre un'istanza di classe in più variabili in una singola espressione. Il lato sinistro contiene un elenco di variabili tra parentesi, il lato destro contiene l'oggetto da scomporre. Kotlin chiama automaticamente la funzione componentN() corrispondente per ogni variabile, dove N è il numero ordinale della variabile tra parentesi.

La dichiarazione di destrutturazione è più comunemente utilizzata con le data class. Il compilatore Kotlin genera automaticamente component1(), component2() e così via per ogni data class — in base al numero di proprietà nel costruttore primario. Per le classi regolari senza il modificatore data, componentN() non vengono generati, ma possono essere definiti manualmente come funzioni operatore con la parola chiave operator.

La dichiarazione di destrutturazione è diventata un pattern popolare grazie alla sua capacità di semplificare il codice quando si lavora con collezioni di coppie, risultati di funzioni e iterazione di Map. Invece di scrivere person.firstName, person.lastName, lo sviluppatore scrive val (firstName, lastName) = person. Ciò riduce il numero di righe e migliora la leggibilità, specialmente in cicli e lambda.

Come funziona la destrutturazione in Kotlin?

Quando incontra la costruzione val (a, b) = obj, il compilatore Kotlin genera il seguente codice: val a = obj.component1(); val b = obj.component2(). Se le variabili sono dichiarate con var, vengono generate assegnazioni var. Il tipo di ogni variabile viene dedotto dal tipo di ritorno della corrispondente funzione componentN(). Ciò significa che la dichiarazione di destrutturazione è completamente type-safe e verificata in fase di compilazione.

data class Person(val firstName: String, val lastName: String, val age: Int)

fun main() {
    val person = Person("Alice", "Smith", 30)

    // Destrutturazione: component1(), component2(), component3()
    val (firstName, lastName, age) = person
    println("$firstName $lastName, $age anni")
}

Nel listato, Person è una data class con tre proprietà. Kotlin genera component1() → firstName, component2() → lastName, component3() → age. L'espressione val (firstName, lastName, age) = person chiama queste funzioni e assegna i risultati. Importante: i nomi delle variabili non devono corrispondere ai nomi delle proprietà — il compilatore osserva solo l'ordine di componentN() e i loro tipi. È possibile scomporre solo le prime N proprietà, ignorando il resto.

Destrutturazione di data classes e tipi standard

Le data class sono i candidati principali per la dichiarazione di destrutturazione. Ogni data class ottiene automaticamente componentN() per tutte le proprietà del costruttore primario. L'ordine di componentN() corrisponde all'ordine di dichiarazione delle proprietà. Ciò significa che quando si modifica l'ordine dei campi in una data class, anche l'ordine delle variabili nella destrutturazione cambia — il che può portare a bug sottili.

// Destrutturazione di Pair
val pair = Pair("key", 42)
val (key, value) = pair
println("$key -> $value")

// Destrutturazione di Triple
val triple = Triple("A", "B", "C")
val (first, second, third) = triple

// Map.Entry nel ciclo
val map = mapOf("a" to 1, "b" to 2)
for ((k, v) in map) {
    println("$k = $v")
}

Pair e Triple sono classi standard con destrutturazione integrata per due e tre componenti. Pair viene spesso utilizzato come tipo di ritorno per funzioni che devono restituire due valori correlati senza creare una data class separata. In un ciclo for su Map.Entry, la costruzione (k, v) = entry destruttura la chiave e il valore tramite component1() e component2(). Questo è il pattern standard per iterare su una Map in Kotlin, sostituendo completamente le chiamate esplicite a key e value.

Trattino basso per variabili inutilizzate

Se alcuni componenti non sono necessari durante la destrutturazione, Kotlin consente di sostituirli con un trattino basso _. Ciò migliora la leggibilità — il lettore vede immediatamente che il componente viene ignorato. Inoltre, l'uso di _ impedisce l'accesso accidentale a una variabile non inizializzata: il compilatore non crea alcuna variabile per _, eliminando gli avvisi sulle variabili inutilizzate.

data class Order(
    val id: Long,
    val customerName: String,
    val amount: Double,
    val status: String
)

fun process(orders: List<Order>) {
    for ((id, _, amount) in orders) {
        println("Ordine $id: $amount")
    }
}

Nel listato, Order ha quattro proprietà, ma il ciclo necessita solo di id e amount. Il trattino basso al posto di customerName dice al compilatore “salta component2()”. Kotlin non chiama component2() e non crea una variabile per questo componente. Importante: i trattini bassi possono essere utilizzati solo nelle dichiarazioni di destrutturazione, non nel costruttore della data class. Se vengono saltati più componenti consecutivi, ciascuno riceve il proprio trattino basso.

Creazione di componentN() per classi personalizzate

Per le classi senza il modificatore data, è possibile definire manualmente componentN() aggiungendo la parola chiave operator. Ciò consente di utilizzare la dichiarazione di destrutturazione con qualsiasi classe, incluse classi di terze parti il cui codice sorgente non può essere modificato — basta scrivere una funzione di estensione con operator. Questo approccio è particolarmente utile per classi di librerie e classi Java che non hanno componentN() automatici.

class Rect(val width: Int, val height: Int)

operator fun Rect.component1(): Int = width
operator fun Rect.component2(): Int = height

// Per classe Java con getters
operator fun Dimension.component1(): Int = width
operator fun Dimension.component2(): Int = height

fun main() {
    val rect = Rect(1920, 1080)
    val (w, h) = rect
    println("Risoluzione: ${w}x${h}")
}

Nell'esempio, Rect è una classe regolare senza data. Le funzioni di estensione con operator fun component1() = width e component2() = height aggiungono il supporto alla destrutturazione. Analogamente per java.awt.Dimension: un'estensione operator su Dimension consente di scomporlo in width e height. Limitazione: il numero massimo di componenti per una dichiarazione di destrutturazione è 5. In teoria è possibile definire component6() e superiori, ma Kotlin non genererà la sintassi corrispondente per 6+ variabili tra parentesi.