Kotlin/multi declarations

التصريح بالتفكيك

قد تحتاج في بعض الأحيان لتفكيك الكائن (object) إلى عددٍ من المتحولات، مثل:

val (name, age) = person

تٌسمَّى الصيغة السابقة بالتصريح بالتفكيك والذي يُنشِئ أكثر من متحولٍ بنفس الوقت (وهما المتحولان name و age) حيث يُسمح باستخدامهما بشكلٍ مستقلٍ تمامًا كما في الشيفرة الآتية:

println(name)
println(age)

إذ يُترجَم التصريح بالتفكيك كما يلي:

val name = person.component1()
val age = person.component2()

حيث تُعدُّ الدالتان component1()‎ و component2()‎ مثالًا عن الاصطلاحات الأساسيّة المُستخدَمة في لغة Kotlin (راجع المُعامِلات مثل + و * وحلقات for و... إلخ.)، ويُسمَح بوجود أيّ كائنٍ في الجانب الأيمن من التصريح بالتفكيك طالما أمكن استدعاء العدد المطلوب من دوال الأجزاء (component functions) عبره (قد تكون بالأسماء component3()‎ و component4()‎ وهكذا) والتي يجب أن تُحدَّد بالكلمة المفتاحيّة operator للسماح باستخدامها في هذا التصريح. كما ويُستفاد من التصريح بالتفكيك في حلقة for بالشكل:

for ((a, b) in collection) { ... }

حيث تحصل المتحولات a و b على القيم من استدعاء الدالتين component1()‎ و component2()‎ في عناصر المجموعة (collection).

تطبيقٌ عمليٌّ: إعادة قيمتين من الدالة

عند الحاجة إلى إعادة عنصرين من الدالة (لنقل مثلًا إعادة كائن النتيجة وحالةٍ ما) فإن الطريقة المُتَّفق عليها للقيام بذلك هي إنشاء صنفٍ للبيانات (data class) وإعادة كائنٍ منه، كما في الشيفرة الآتية:

data class Result(val result: Int, val status: Status)
fun function(...): Result {
    // بعض الحسابات
    
    return Result(result, status)
}

// الآن.. استخدام الدالة
val (result, status) = function(...)

ويُسمَح باستخدام التصريح بالتفكيك هنا لأنّ أصناف البيانات تعرِّف دوال الأجزاء componentN()‎ تلقائيًا.

ملاحظة: يمكن استخدام الصنف القياسي Pair لتعيد الدالة function()‎ النوع Pair<Int, Status>‎، ولكن من الأفضل تسميةُ البيانات بما يتناسب مع استخدامها.

تطبيقٌ عمليٌّ: التصريحات المُفكَّكة و Maps

إنّ الطريقة الأنسب للمرور بعناصر map هي كما في الشيفرة الآتية:

for ((key, value) in map) {
   // القيام بالتعليمات استنادًا إلى القيمة والمفتاح
}

وهنا يجب التقيد بما يلي:

• تمثيل كائن map كتسلسلٍ (sequence) من القيم من خلال الدالة iterator()‎
• تمثيل كلٍّ من العناصر كزوجٍ (pair) من خلال الدالتين ‎component1()‎ و component2()‎‎

إذ تزوِّد المكتبة القياسية بمثل هذه الإضافات:

operator fun <K, V> Map<K, V>.iterator(): Iterator<Map.Entry<K, V>> = entrySet().iterator()
operator fun <K, V> Map.Entry<K, V>.component1() = getKey()
operator fun <K, V> Map.Entry<K, V>.component2() = getValue()

مما يجعل من السهل استخدام التصريحات بالتفكيك في حلقات for بالاعتماد على maps (وكذلك كائنات مجموعات أصناف البيانات [collections of data class instances] وما يماثلها).

استخدام الشرطة السفليّة (_) للمتحولات غير المُستخدَمة (بدءًا من الإصدار 1.1)

إن لم يكن هناك حاجةٌ للمتحوّل في التصريح بالتفكيك فيمكن الاستغناءُ عن اسمه بالشرطة السفليّة مثل:

val (_, status) = getResult()

وبهذه الطريقة لن تُستدعَى دالة الجزء (component function) الموافقةِ له.

التفكيك في lambdas (بدءًا من الإصدار 1.1)

تُستخدَم صيغةُ التصريحات بالتفكيك في متحولات lambda أيضًا، وإذا كان متحول lambda من النوع Pair (أو من النوع Map.Entry أو أي نوعٍ آخر يحتوي على دالة جزءٍ [component function] مناسبةٍ) فيُمكن حينئذٍ استخدام أكثر من متحولٍ (تُحاط المتحولات بالأقواس ())، كما في الشيفرة الآتية:

map.mapValues { entry -> "${entry.value}!" }
map.mapValues { (key, value) -> "$value!" }

ويتَّضِح الفرق بين التصريح عن متحوِّلين والتصريح عنهما بالتفكيك، كما يلي:

{ a -> ... } // متحول واحد
{ a, b -> ... } // متحولان
{ (a, b) -> ... } // تصريح مفكك بمتحولين
{ (a, b), c -> ... } // تصريح مفكك بمتحولين ومتحول ثالث مستقل

فإن كان أحد أجزاء التصريح بالتفكيك غير مستخدمٍ يُستعاض عنه بالشرطة السفليّة دون الحاجة لتسميته، مثل:

map.mapValues { (_, value) -> "$value!" }

كما ويمكن تحديد النوع الإجماليّ لمتحولات التصريح بالتفكيك أو لمتحولٍ واحدٍ منها بشكلٍ منفصلٍ كما في الشيفرة الآتية:

map.mapValues { (_, value): Map.Entry<Int, String> -> "$value!" }

map.mapValues { (_, value: String) -> "$value!" }

مصادر

• صفحة التصريح بالتفكيك في التوثيق الرسميّ للغة Kotlin