Destructuring declaration — یہ کیا ہے، نحو اور Kotlin میں استعمال

destructuring declaration کیا ہے؟

Destructuring declaration (ڈی سٹرکچرنگ اعلان) — یہ Kotlin کی ایک نحوی تعمیر ہے جس سے کسی کلاس کے نمونے کو ایک ہی اظہار میں کئی متغیرات میں تحلیل کیا جا سکتا ہے۔ بایاں حصہ قوسین میں متغیرات کی فہرست رکھتا ہے، دایاں حصہ — تحلیل کیے جانے والا آبجیکٹ۔ Kotlin ہر متغیر کے لیے خودکار طور پر متعلقہ componentN() فنکشن بلاتا ہے، جہاں N قوسین میں متغیر کا ترتیبی نمبر ہے۔

سب سے زیادہ عام طور پر destructuring declaration data class کے ساتھ استعمال ہوتی ہے۔ Kotlin کمپائلر data class کے لیے خودکار طور پر component1()، component2() اور اسی طرح کے دیگر فنکشنز تیار کرتا ہے — پرائمری کنسٹرکٹر میں خصوصیات کی تعداد کے مطابق۔ عام کلاسز کے لیے جو data موڈیفائر کے بغیر ہیں، componentN() تیار نہیں ہوتے، لیکن انہیں operator کلیدی لفظ کے ساتھ آپریٹر فنکشنز کے طور پر دستی طور پر بیان کیا جا سکتا ہے۔

Destructuring declaration کوڈ کو آسان بنانے کی اپنی صلاحیت کی وجہ سے ایک مقبول نمونہ بن گئی ہے — جوڑوں کے مجموعوں، فنکشنز کے نتائج اور 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() فنکشن کے لوٹائے جانے والے نتائج کی قسم سے اخذ کی جاتی ہے۔ اس کا مطلب ہے کہ destructuring declaration مکمل طور پر ٹائپ سیف ہے اور کمپائیلیشن کے مرحلے پر جانچی جاتی ہے۔

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 class اور معیاری اقسام کی ڈی سٹرکچرنگ

Data class destructuring declaration کے لیے بنیادی امیدوار ہے۔ ہر 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() کو نہیں بلاتا اور اس جزو کے لیے کوئی متغیر نہیں بناتا۔ اہم: انڈر سکور صرف destructuring declaration میں استعمال کیا جا سکتا ہے، لیکن data class کنسٹرکٹر میں نہیں۔ اگر کئی اجزاء لگاتار چھوڑے جائیں تو ہر ایک کے لیے اپنا انڈر سکور ہوتا ہے۔

اپنی کلاسز کے لیے componentN() بنانا

data موڈیفائر کے بغیر کلاسز کے لیے operator کلیدی لفظ شامل کرکے componentN() کو دستی طور پر بیان کیا جا سکتا ہے۔ یہ کسی بھی کلاس کے ساتھ destructuring declaration استعمال کرنے کی اجازت دیتا ہے، بشمول تیسری پارٹی کی کلاسز جن کے سورس کوڈ میں تبدیلی ممکن نہیں — operator کے ساتھ extension فنکشن لکھنا کافی ہے۔ یہ نقطہ نظر خاص طور پر لائبریری کلاسز اور 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 کے ساتھ extension فنکشنز ڈی سٹرکچرنگ کے لیے سپورٹ شامل کرتی ہیں۔ اسی طرح java.awt.Dimension کے لیے: Dimension پر operator extension اسے width اور height میں تحلیل کرنے کی اجازت دیتا ہے۔ حد: destructuring declaration کے لیے اجزاء کی زیادہ سے زیادہ تعداد 5 ہے۔ نظریاتی طور پر component6() اور اس سے آگے بیان کیا جا سکتا ہے، لیکن Kotlin قوسین میں 6+ متغیرات کے لیے متعلقہ نحو تیار نہیں کرے گا۔