Destructuring declaration — यह क्या है, सिंटैक्स और Kotlin में उपयोग

डिस्ट्रक्चरिंग डिक्लेरेशन क्या है?

Destructuring declaration (विघटन घोषणा) Kotlin की एक सिंटैक्टिक कंस्ट्रक्शन है जो आपको एक क्लास इंस्टेंस को एक ही एक्सप्रेशन में कई वेरिएबल्स में विघटित करने की अनुमति देती है। बायीं तरफ कोष्ठक में वेरिएबल्स की एक सूची होती है, दायीं तरफ विघटित किया जा रहा ऑब्जेक्ट होता है। Kotlin स्वचालित रूप से प्रत्येक वेरिएबल के लिए संबंधित componentN() फ़ंक्शन को कॉल करता है, जहाँ N कोष्ठक में वेरिएबल की क्रम संख्या है।

डिस्ट्रक्चरिंग डिक्लेरेशन का सबसे अधिक उपयोग data classes के साथ किया जाता है। Kotlin कंपाइलर प्रत्येक data class के लिए प्राथमिक कंस्ट्रक्टर में गुणों की संख्या के आधार पर स्वचालित रूप से component1(), component2() इत्यादि उत्पन्न करता है। data मॉडिफ़ायर के बिना सामान्य कक्षाओं के लिए, componentN() उत्पन्न नहीं होते हैं, लेकिन उन्हें operator कीवर्ड के साथ मैन्युअल रूप से परिभाषित किया जा सकता है।

डिस्ट्रक्चरिंग डिक्लेरेशन जोड़ियों के संग्रह, फ़ंक्शन परिणामों और Map पुनरावृत्ति के साथ काम करते समय कोड को सरल बनाने की अपनी क्षमता के कारण एक लोकप्रिय पैटर्न बन गया है। person.firstName, person.lastName लिखने के बजाय, डेवलपर val (firstName, lastName) = person लिखता है। यह पंक्तियों की संख्या को कम करता है और विशेष रूप से लूप्स और लैम्ब्डा में पठनीयता में सुधार करता है।

Kotlin में डिस्ट्रक्चरिंग कैसे काम करती है?

val (a, b) = obj कंस्ट्रक्ट का सामना करने पर, Kotlin कंपाइलर निम्नलिखित कोड उत्पन्न करता है: val a = obj.component1(); val b = obj.component2(). यदि वेरिएबल्स var के साथ घोषित किए गए हैं, तो var असाइनमेंट उत्पन्न होते हैं। प्रत्येक वेरिएबल का प्रकार संबंधित componentN() फ़ंक्शन के रिटर्न प्रकार से अनुमानित होता है। इसका मतलब है कि डिस्ट्रक्चरिंग डिक्लेरेशन पूरी तरह से टाइप-सुरक्षित है और संकलन समय पर जाँची जाती है।

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

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

    // डिस्ट्रक्चरिंग: component1(), component2(), component3()
    val (firstName, lastName, age) = person
    println("$firstName $lastName, $age वर्ष पुराना")
}

लिस्टिंग में, Person तीन गुणों वाली एक data class है। Kotlin component1() → firstName, component2() → lastName, component3() → age उत्पन्न करता है। अभिव्यक्ति val (firstName, lastName, age) = person इन फ़ंक्शन को कॉल करती है और परिणाम प्रदान करती है। महत्वपूर्ण: वेरिएबल नामों का गुण नामों से मेल खाना आवश्यक नहीं है — कंपाइलर केवल componentN() के क्रम और उनके प्रकारों को देखता है। आप केवल पहले N गुणों को विघटित कर सकते हैं, बाकी को अनदेखा कर सकते हैं।

data classes और मानक प्रकारों की डिस्ट्रक्चरिंग

Data classes डिस्ट्रक्चरिंग डिक्लेरेशन के लिए प्राथमिक उम्मीदवार हैं। प्रत्येक data class स्वचालित रूप से प्राथमिक कंस्ट्रक्टर के सभी गुणों के लिए componentN() प्राप्त करती है। componentN() का क्रम गुण घोषणाओं के क्रम से मेल खाता है। इसका मतलब है कि जब आप data class में फ़ील्ड का क्रम बदलते हैं, तो डिस्ट्रक्चरिंग में वेरिएबल्स का क्रम भी बदल जाता है — जो सूक्ष्म बग का कारण बन सकता है।

// Pair डिस्ट्रक्चरिंग
val pair = Pair("key", 42)
val (key, value) = pair
println("$key -> $value")

// Triple डिस्ट्रक्चरिंग
val triple = Triple("A", "B", "C")
val (first, second, third) = triple

// Map.Entry लूप में
val map = mapOf("a" to 1, "b" to 2)
for ((k, v) in map) {
    println("$k = $v")
}

Pair और Triple दो और तीन घटकों के लिए अंतर्निहित डिस्ट्रक्चरिंग वाली मानक कक्षाएं हैं। Pair का उपयोग अक्सर उन फ़ंक्शनों के लिए रिटर्न प्रकार के रूप में किया जाता है जिन्हें एक अलग data class बनाए बिना दो संबंधित मान लौटाने की आवश्यकता होती है। Map.Entry पर for लूप में, (k, v) = entry कंस्ट्रक्ट component1() और component2() के माध्यम से कुंजी और मान को विघटित करता है। Kotlin में Map पर पुनरावृत्ति करने का यह मानक पैटर्न है, जो पूरी तरह से key और value के स्पष्ट कॉल को बदल देता है।

अप्रयुक्त वेरिएबल्स के लिए अंडरस्कोर

यदि डिस्ट्रक्चरिंग के दौरान कुछ घटकों की आवश्यकता नहीं है, तो Kotlin आपको उन्हें अंडरस्कोर _ से बदलने की अनुमति देता है। इससे पठनीयता में सुधार होता है — पाठक तुरंत देखता है कि घटक को अनदेखा किया जा रहा है। इसके अलावा, _ का उपयोग एक अप्रारंभिक वेरिएबल तक आकस्मिक पहुँच को रोकता है: कंपाइलर _ के लिए कोई वेरिएबल नहीं बनाता है, जिससे अप्रयुक्त वेरिएबल्स के बारे में चेतावनियाँ समाप्त हो जाती हैं।

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("आदेश $id: $amount")
    }
}

लिस्टिंग में, Order में चार गुण हैं, लेकिन लूप को केवल id और amount की आवश्यकता है। customerName के स्थान पर अंडरस्कोर कंपाइलर को बताता है “component2() को छोड़ें”। Kotlin component2() को कॉल नहीं करता और इस घटक के लिए कोई वेरिएबल नहीं बनाता। महत्वपूर्ण: अंडरस्कोर का उपयोग केवल डिस्ट्रक्चरिंग डिक्लेरेशन में किया जा सकता है, data class कंस्ट्रक्टर में नहीं। यदि कई लगातार घटकों को छोड़ा जाता है, तो प्रत्येक को अपना स्वयं का अंडरस्कोर मिलता है।

कस्टम कक्षाओं के लिए componentN() बनाना

data मॉडिफ़ायर के बिना कक्षाओं के लिए, आप operator कीवर्ड जोड़कर मैन्युअल रूप से componentN() परिभाषित कर सकते हैं। यह आपको किसी भी क्लास के साथ डिस्ट्रक्चरिंग डिक्लेरेशन का उपयोग करने की अनुमति देता है, जिसमें तीसरे पक्ष की कक्षाएं शामिल हैं जिनका स्रोत कोड संशोधित नहीं किया जा सकता — बस operator के साथ एक एक्सटेंशन फ़ंक्शन लिखें। यह दृष्टिकोण विशेष रूप से लाइब्रेरी कक्षाओं और Java कक्षाओं के लिए उपयोगी है जिनमें स्वचालित componentN() नहीं है।

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

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

// getters वाली Java क्लास के लिए
operator fun Dimension.component1(): Int = width
operator fun Dimension.component2(): Int = height

fun main() {
    val rect = Rect(1920, 1080)
    val (w, h) = rect
    println("रिज़ॉल्यूशन: ${w}x${h}")
}

उदाहरण में, Rect बिना data के एक सामान्य क्लास है। operator fun component1() = width और component2() = height के साथ एक्सटेंशन फ़ंक्शन डिस्ट्रक्चरिंग समर्थन जोड़ते हैं। इसी प्रकार java.awt.Dimension के लिए: Dimension पर एक operator एक्सटेंशन इसे width और height में विघटित करने की अनुमति देता है। सीमा: डिस्ट्रक्चरिंग डिक्लेरेशन के लिए घटकों की अधिकतम संख्या 5 है। सिद्धांत रूप में आप component6() और उससे ऊपर परिभाषित कर सकते हैं, लेकिन Kotlin कोष्ठक में 6+ वेरिएबल्स के लिए संबंधित सिंटैक्स उत्पन्न नहीं करेगा।