Destructuring declaration — ce este, sintaxa și aplicarea în Kotlin

Ce este destructuring declaration?

Destructuring declaration (declarație de destructurare) — este o construcție sintactică Kotlin care permite descompunerea unei instanțe de clasă în mai multe variabile într-o singură expresie. Partea stângă conține lista de variabile în paranteze, partea dreaptă — obiectul de descompus. Kotlin apelează automat pentru fiecare variabilă funcția componentN() corespunzătoare, unde N este numărul de ordine al variabilei în paranteze.

Destructuring declaration se utilizează cel mai frecvent cu data class. Compilatorul Kotlin generează automat pentru data class funcțiile component1(), component2() și așa mai departe — după numărul de proprietăți în constructorul primar. Pentru clasele obișnuite fără modificatorul data, componentN() nu se generează, dar pot fi definite manual ca funcții operator cu cuvântul cheie operator.

Destructuring declaration a devenit un model popular datorită capacității sale de a simplifica codul la lucrul cu colecții de perechi, rezultate ale funcțiilor și parcurgerea Map. În loc de person.firstName, person.lastName, programatorul scrie val (firstName, lastName) = person. Aceasta reduce numărul de linii și crește lizibilitatea, în special în bucle și lambda.

Cum funcționează destructurarea în Kotlin?

La întâlnirea construcției val (a, b) = obj, compilatorul Kotlin generează codul: val a = obj.component1(); val b = obj.component2(). Dacă variabilele sunt declarate cu var, se generează atribuiri var. Tipul fiecărei variabile este dedus din tipul de returnare al funcției componentN() corespunzătoare. Aceasta înseamnă că destructuring declaration este complet sigură din punct de vedere al tipurilor și se verifică în faza de compilare.

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

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

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

În listarea Person — data class cu trei proprietăți. Kotlin generează component1() → firstName, component2() → lastName, component3() → age. Expresia val (firstName, lastName, age) = person apelează aceste funcții și atribuie rezultatele. Important: numele variabilelor pot să nu coincidă cu numele proprietăților — compilatorul se uită doar la ordinea componentN() și tipurile lor. Se pot descompune doar primele N proprietăți, ignorându-le pe celelalte.

Destructurarea data class și a tipurilor standard

Data class — candidatul principal pentru destructuring declaration. Fiecare data class primește automat componentN() pentru toate proprietățile constructorului primar. Ordinea componentN() corespunde ordinii de declarare a proprietăților. Aceasta înseamnă că la modificarea ordinii câmpurilor în data class se modifică ordinea variabilelor în destructurare — ceea ce poate duce la bug-uri invizibile.

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

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

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

Pair și Triple — clase standard cu destructurare gata făcută pentru două și trei componente. Pair este adesea folosit ca tip de returnare al funcțiilor care trebuie să returneze două valori legate fără a crea un data class separat. în bucla for pe Map.Entry, construcția (k, v) = entry destructura cheia și valoarea prin component1() și component2(). Acesta este modelul standard de parcurgere a Map în Kotlin, înlocuind complet apelurile explicite key și value.

Subînțelegerea pentru variabilele neutilizate

Dacă la destructurare unele componente nu sunt necesare, Kotlin permite înlocuirea lor cu subînțelegerea _. Aceasta îmbunătățește lizibilitatea — cititorul vede imediat că componenta este ignorată. În plus, utilizarea _ previne accesarea accidentală a unei variabile neinițializate: compilatorul nu creează nicio variabilă pentru _, ceea ce elimină avertismentele despre variabilele neutilizate.

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("Comanda $id: $amount")
    }
}

În listarea Order are patru proprietăți, dar în buclă sunt necesare doar id și amount. Subînțelegerea în locul customerName spune compilatorului „sari peste component2()”. Kotlin nu apelează component2() și nu creează o variabilă pentru această componentă. Important: subînțelegerea poate fi folosită doar în destructuring declaration, dar nu în constructorul data class. Dacă se sar mai multe componente consecutiv, fiecăreia îi corespunde propria subînțelegere.

Crearea componentN() pentru clase proprii

Pentru clasele fără modificatorul data se poate defini manual componentN(), adăugând cuvântul cheie operator. Aceasta permite utilizarea destructuring declaration cu orice clasă, inclusiv externe, pentru care codul sursă nu poate fi modificat — este suficient să scrieți o funcție de extensie cu operator. Această abordare este deosebit de utilă pentru clasele de bibliotecă și clasele din codul Java care nu au componentN() automat.

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

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

// Pentru clasa Java cu gettere
operator fun Dimension.component1(): Int = width
operator fun Dimension.component2(): Int = height

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

în exemplu Rect — o clasă obișnuită fără data. Funcțiile de extensie cu operator fun component1() = width și component2() = height adaugă suport pentru destructurare. Similar pentru java.awt.Dimension: extensia operator pe Dimension permite descompunerea în width și height. Limitare: numărul maxim de componente pentru destructuring declaration — 5. În teorie se pot defini component6() și mai sus, dar Kotlin nu va genera sintaxa corespunzătoare pentru 6+ variabile în paranteze.