تفكيك التصريحات (Destructuring Declarations) في لغة Kotlin
التصريح المُفكّك
قد تحتاج في بعض الأحيان لتفكيك الكائن (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!" }