Destructuring declaration — ano ito, syntax at aplikasyon sa Kotlin

Ano ang destructuring declaration?

Destructuring declaration (destructuring na deklarasyon) — ay isang syntactic na konstruksiyon sa Kotlin na nagpapahintulot sa iyo na i-decompose ang isang instance ng klase sa maraming variable sa isang expression. Ang kaliwang bahagi ay naglalaman ng listahan ng mga variable sa panaklong, ang kanang bahagi — ang object na ide-decompose. Awtomatikong tinatawag ng Kotlin para sa bawat variable ang kaukulang function na componentN(), kung saan ang N ay ang ordinal na numero ng variable sa panaklong.

Ang destructuring declaration ay kadalasang ginagamit sa data class. Ang Kotlin compiler ay awtomatikong bumubuo para sa data class ng mga function na component1(), component2() at iba pa — ayon sa bilang ng mga property sa primary constructor. Para sa mga ordinaryong klase na walang modifier na data, hindi nabubuo ang componentN(), ngunit maaari silang manu-manong tukuyin bilang mga operator function na may keyword na operator.

Ang destructuring declaration ay naging isang popular na pattern dahil sa kakayahan nitong pasyahin ang code kapag nagtatrabaho sa mga koleksyon ng mga pares, mga resulta ng function, at pag-browse sa Map. Sa halip na magsulat ng person.firstName, person.lastName, ang developer ay nagsusulat ng val (firstName, lastName) = person. Binabawasan nito ang bilang ng mga linya at pinapataas ang pagiging nababasa, lalo na sa mga loop at lambda.

Paano gumagana ang destructuring sa Kotlin?

Kapag nakatagpo ng konstruksiyon na val (a, b) = obj, ang Kotlin compiler ay bumubuo ng code: val a = obj.component1(); val b = obj.component2(). Kung ang mga variable ay idineklara gamit ang var, nabubuo ang mga var assignment. Ang uri ng bawat variable ay inferred mula sa return type ng kaukulang function na componentN(). Ito ay nangangahulugan na ang destructuring declaration ay ganap na type-safe at sinusuri sa yugto ng compilation.

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

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

    // Destructuring: component1(), component2(), component3()
    val (firstName, lastName, age) = person
    println("$firstName $lastName, $age taong gulang")
}

Sa listing Person — data class na may tatlong property. Bumubuo ang Kotlin ng component1() → firstName, component2() → lastName, component3() → age. Ang expression na val (firstName, lastName, age) = person ay tumatawag sa mga function na ito at nagtatalaga ng mga resulta. Mahalaga: ang mga pangalan ng variable ay maaaring hindi tumugma sa mga pangalan ng property — ang compiler ay tumitingin lamang sa pagkakasunod-sunod ng componentN() at kanilang mga uri. Maaari mo lamang i-decompose ang unang N property, hindi pinapansin ang iba.

Destructuring ng data class at mga karaniwang uri

Data class — ang pangunahing kandidato para sa destructuring declaration. Bawat data class ay awtomatikong nakakakuha ng componentN() para sa lahat ng property ng primary constructor. Ang pagkakasunod-sunod ng componentN() ay tumutugma sa pagkakasunod-sunod ng deklarasyon ng mga property. Ito ay nangangahulugan na kapag binago ang pagkakasunod-sunod ng mga field sa data class, nagbabago ang pagkakasunod-sunod ng mga variable sa destructuring — na maaaring humantong sa mga hindi nakikitang bug.

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

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

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

Pair at Triple — mga karaniwang klase na may handa nang destructuring para sa dalawa at tatlong component. Ang Pair ay madalas na ginagamit bilang return type ng mga function na kailangang magbalik ng dalawang magkaugnay na halaga nang hindi lumilikha ng hiwalay na data class. Sa for loop sa Map.Entry, ang konstruksiyon na (k, v) = entry ay nagde-destructure ng key at value sa pamamagitan ng component1() at component2(). Ito ang karaniwang pattern para sa pag-browse ng Map sa Kotlin, na ganap na pumapalit sa mga explicit na tawag sa key at value.

Underscore para sa hindi ginamit na mga variable

Kung sa destructuring ang ilang component ay hindi kailangan, pinapayagan ng Kotlin na palitan ang mga ito ng underscore _. Pinapabuti nito ang pagiging nababasa — agad na nakikita ng mambabasa na ang component ay hindi pinansin. Bukod pa rito, ang paggamit ng _ ay pumipigil sa aksidenteng pag-access sa isang hindi na-initialize na variable: ang compiler ay hindi lumilikha ng anumang variable para sa _, na nag-aalis ng mga babala tungkol sa hindi ginamit na mga variable.

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

Sa listing Order ay may apat na property, ngunit sa loop id at amount lamang ang kailangan. Ang underscore sa lugar ng customerName ay nagsasabi sa compiler ‘laktawan ang component2()’. Hindi tinatawag ng Kotlin ang component2() at hindi lumilikha ng variable para sa component na ito. Mahalaga: ang underscore ay maaari lamang gamitin sa destructuring declaration, ngunit hindi sa constructor ng data class. Kung maraming component ang nilalaktawan nang sunud-sunod, bawat isa ay may sariling underscore.

Paglikha ng componentN() para sa sariling mga klase

Para sa mga klase na walang modifier na data, maaari mong manu-manong tukuyin ang componentN() sa pamamagitan ng pagdaragdag ng keyword na operator. Ito ay nagpapahintulot sa paggamit ng destructuring declaration sa anumang klase, kabilang ang mga third-party na klase na hindi mababago ang source code — sapat na na magsulat ng extension function na may operator. Ang approach na ito ay lalong kapaki-pakinabang para sa mga library class at mga klase mula sa Java code na walang awtomatikong componentN().

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

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

// Para sa Java class na may 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("Resolusyon: ${w}x${h}")
}

Sa halimbawa Rect — isang ordinaryong klase na walang data. Ang mga extension function na may operator fun component1() = width at component2() = height ay nagdaragdag ng suporta para sa destructuring. Gayundin para sa java.awt.Dimension: ang operator extension sa Dimension ay nagpapahintulot na i-decompose ito sa width at height. Limitasyon: ang maximum na bilang ng mga component para sa destructuring declaration — 5. Sa teorya maaari mong tukuyin ang component6() at mas mataas, ngunit ang Kotlin ay hindi bubuo ng kaukulang syntax para sa 6+ na variable sa panaklong.