‫Kotlin Bootcamp للمبرمجين 6: المعالجة الوظيفية

هذا الدرس العملي حول الترميز هو جزء من دورة Kotlin التدريبية للمبرمجين. يمكنك تحقيق أقصى استفادة من هذه الدورة التدريبية إذا اتبعت ترتيب الخطوات في دروس البرمجة. استنادًا إلى معرفتك، قد تتمكّن من قراءة بعض الأقسام بسرعة. هذه الدورة التدريبية موجّهة للمبرمجين الذين يعرفون لغة برمجة تعتمد على العناصر ويريدون تعلُّم Kotlin.

مقدمة

هذا هو الدرس العملي الأخير في "برنامج Kotlin التدريبي". في هذا الدرس العملي، ستتعرّف على التعليقات التوضيحية وفواصل الأسطر المصنّفة. تراجِع تعبيرات lambda والدوال ذات الترتيب الأعلى، وهما جزءان أساسيان من Kotlin. يمكنك أيضًا التعرّف على المزيد حول الدوال المضمّنة وواجهات Single Abstract Method (SAM). أخيرًا، ستتعرّف على المزيد من المعلومات حول مكتبة Kotlin العادية.

بدلاً من إنشاء تطبيق نموذجي واحد، تم تصميم الدروس في هذه الدورة التدريبية لتعزيز معرفتك، ولكنها شبه مستقلة عن بعضها البعض حتى تتمكن من تصفّح الأقسام التي تعرفها. ولربطها ببعضها، تستخدم العديد من الأمثلة سمة حوض السمك. إذا أردت الاطّلاع على قصة حوض السمك بالكامل، يمكنك الرجوع إلى دورة Kotlin Bootcamp للمبرمجين على Udacity.

ما يجب معرفته

• بنية دوال وفئات وطُرق Kotlin
• كيفية إنشاء صف جديد في IntelliJ IDEA وتشغيل برنامج
• أساسيات دوال lambda والدوال ذات الترتيب الأعلى

أهداف الدورة التعليمية

• أساسيات التعليقات التوضيحية
• كيفية استخدام فواصل مصنّفة
• مزيد من المعلومات حول الدوال ذات الترتيب الأعلى
• لمحة عن واجهات Single Abstract Method (SAM)
• لمحة عن "مكتبة Kotlin العادية"

الإجراءات التي ستنفذّها

• إنشاء تعليق توضيحي بسيط
• استخدام فاصل مصنّف
• راجِع دوال lambda في Kotlin.
• استخدام الدوال ذات الترتيب الأعلى وإنشاؤها
• استدعاء بعض واجهات Single Abstract Method
• استخدام بعض الدوال من مكتبة Kotlin العادية

التعليقات التوضيحية هي طريقة لإرفاق بيانات وصفية بالرمز، وهي ليست شيئًا خاصًا بلغة Kotlin. يقرأ المجمّع التعليقات التوضيحية ويستخدمها لإنشاء الرموز البرمجية أو المنطق. تستخدم العديد من الأُطر، مثل Ktor وKotlinx، بالإضافة إلى Room، التعليقات التوضيحية لتحديد طريقة عملها وتفاعلها مع الرمز البرمجي. من غير المحتمل أن تصادف أي تعليقات توضيحية إلى أن تبدأ في استخدام الأُطر، ولكن من المفيد أن تعرف كيفية قراءة تعليق توضيحي.

تتوفّر أيضًا تعليقات توضيحية من خلال مكتبة Kotlin العادية تتحكّم في طريقة تجميع الرموز البرمجية. وهي مفيدة جدًا عند تصدير Kotlin إلى رمز Java، ولكنّك لن تحتاج إليها كثيرًا في الحالات الأخرى.

تظهر التعليقات التوضيحية قبل العنصر الذي يتم التعليق عليه مباشرةً، ويمكن إضافة تعليقات توضيحية إلى معظم العناصر، مثل الفئات والدوال والطرق وحتى هياكل التحكّم. يمكن أن تتضمّن بعض التعليقات التوضيحية وسيطات.

في ما يلي مثال على بعض التعليقات التوضيحية.

@file:JvmName("InteropFish")
class InteropFish {
   companion object {
       @JvmStatic fun interop()
   }
}

يشير ذلك إلى أنّ الاسم الذي تم تصديره لهذا الملف هو InteropFish مع التعليق التوضيحي JvmName، وأنّ التعليق التوضيحي JvmName يأخذ وسيطة "InteropFish". في الكائن المصاحب، يطلب @JvmStatic من Kotlin تحويل interop() إلى دالة ثابتة في InteropFish.

يمكنك أيضًا إنشاء تعليقات توضيحية خاصة بك، ولكنّها تكون مفيدة في الغالب إذا كنت تكتب مكتبة تحتاج إلى معلومات معيّنة عن الفئات في وقت التشغيل، أي الانعكاس.

الخطوة 1: إنشاء حزمة وملف جديدَين

1. ضمن src، أنشئ حزمة جديدة، example.
2. في example، أنشئ ملف Kotlin جديدًا باسم Annotations.kt.

الخطوة 2: إنشاء تعليق توضيحي خاص بك

1. في Annotations.kt، أنشئ فئة Plant تتضمّن طريقتَين، trim() وfertilize().

class Plant {
        fun trim(){}
        fun fertilize(){}
}

2. أنشئ دالة تطبع جميع الطرق في فئة. استخدِم ::class للحصول على معلومات حول فئة في وقت التشغيل. استخدِم declaredMemberFunctions للحصول على قائمة بطُرق إحدى الفئات. (للوصول إلى هذا، عليك استيراد kotlin.reflect.full.*)

import kotlin.reflect.full.*    // required import

class Plant {
    fun trim(){}
    fun fertilize(){}
}

fun testAnnotations() {
    val classObj = Plant::class
    for (m in classObj.declaredMemberFunctions) {
        println(m.name)
    }
}

3. أنشئ الدالة main() لاستدعاء روتين الاختبار. شغِّل برنامجك وراقِب الناتج.

fun main() {
    testAnnotations()
}

⇒ trim
fertilize

4. أنشئ تعليقًا توضيحيًا بسيطًا، ImAPlant.

annotation class ImAPlant

لا يؤدي هذا الإجراء أي وظيفة أخرى سوى الإشارة إلى أنّ الصورة مشروحة.

4. أضِف التعليق التوضيحي أمام فئة Plant.

@ImAPlant class Plant{
    ...
}

5. غيِّر testAnnotations() لطباعة جميع التعليقات التوضيحية في صف. استخدِم annotations للحصول على جميع التعليقات التوضيحية الخاصة بصف. نفِّذ برنامجك ولاحظ النتيجة.

fun testAnnotations() {
    val plantObject = Plant::class
    for (a in plantObject.annotations) {
        println(a.annotationClass.simpleName)
    }
}

⇒ ImAPlant

6. غيِّر testAnnotations() للعثور على التعليق التوضيحي ImAPlant. استخدِم findAnnotation() للعثور على تعليق توضيحي معيّن. نفِّذ برنامجك ولاحظ النتيجة.

fun testAnnotations() {
    val plantObject = Plant::class
    val myAnnotationObject = plantObject.findAnnotation<ImAPlant>()
    println(myAnnotationObject)
}

⇒ @example.ImAPlant()

الخطوة 3: إنشاء تعليق توضيحي مستهدَف

يمكن أن تستهدف التعليقات التوضيحية دوال الحصول على البيانات أو ضبطها. عندما يتم ذلك، يمكنك تطبيقها باستخدام البادئة @get: أو @set:. يحدث ذلك كثيرًا عند استخدام أُطر مع تعليقات توضيحية.

1. عرِّف تعليقَين توضيحيَين، OnGet الذي يمكن تطبيقه فقط على دوال جلب السمات، وOnSet الذي يمكن تطبيقه فقط على دوال ضبط السمات. استخدِم السمة @Target(AnnotationTarger.PROPERTY_GETTER) أو PROPERTY_SETTER في كل منها.

annotation class ImAPlant

@Target(AnnotationTarget.PROPERTY_GETTER)
annotation class OnGet
@Target(AnnotationTarget.PROPERTY_SETTER)
annotation class OnSet

@ImAPlant class Plant {
    @get:OnGet
    val isGrowing: Boolean = true

    @set:OnSet
    var needsFood: Boolean = false
}

تُعدّ التعليقات التوضيحية فعّالة جدًا لإنشاء مكتبات تفحص العناصر في وقت التشغيل وفي بعض الأحيان في وقت الترجمة البرمجية. ومع ذلك، لا يستخدم رمز التطبيق العادي سوى التعليقات التوضيحية التي توفّرها الأُطر.

تتضمّن لغة Kotlin عدة طرق للتحكّم في التدفق. أنت على دراية بالرمز return الذي يتم إرجاعه من دالة إلى الدالة التي تتضمّنها. استخدام break يشبه return، ولكن بالنسبة إلى الحلقات.

تمنحك لغة Kotlin تحكّمًا إضافيًا في الحلقات باستخدام ما يُعرف باسم الفاصلة المسماة. ينتقل عنصر break مؤهَّل بتصنيف إلى نقطة التنفيذ بعد الحلقة مباشرةً التي تم تصنيفها بهذا التصنيف. ويكون ذلك مفيدًا بشكل خاص عند التعامل مع الحلقات المتداخلة.

يمكن وضع تصنيف على أي تعبير في Kotlin. تتضمّن التصنيفات معرّفًا متبوعًا بالعلامة @.

1. في Annotations.kt، جرِّب استخدام عبارة break مصنّفة من خلال الخروج من حلقة داخلية.

fun labels() {
    outerLoop@ for (i in 1..100) {
         print("$i ")
         for (j in 1..100) {
             if (i > 10) break@outerLoop  // breaks to outer loop
        }
    }
}

fun main() {
    labels()
}

2. شغِّل برنامجك وراقِب الناتج.

⇒ 1 2 3 4 5 6 7 8 9 10 11 

وبالمثل، يمكنك استخدام continue مع تصنيف. بدلاً من الخروج من التكرار الحلقي الذي يحمل تصنيفًا، ينتقل الأمر labeled continue إلى التكرار التالي للتكرار الحلقي.

ملاحظة: لا يمكن استخدام عبارة break المصنّفة في Kotlin إلا للخروج من الحلقات، على عكس goto في C++‎ أو C#‎.

إنّ Lambdas هي دوال مجهولة الهوية، أي دوال بدون اسم. يمكنك تعيينها إلى متغيرات وتمريرها كوسيطات إلى الدوال والطرق. وهي مفيدة للغاية.

الخطوة 1: إنشاء دالة lambda بسيطة

1. ابدأ REPL في IntelliJ IDEA، الأدوات > Kotlin > Kotlin REPL.
2. أنشئ دالة lambda تتضمّن وسيطًا، dirty: Int، وتجري عملية حسابية تقسم dirty على 2. عيِّن تعبير lambda لمتغيّر، waterFilter.

val waterFilter = { dirty: Int -> dirty / 2 }

3. استدعِ الدالة waterFilter، مع تمرير القيمة 30.

waterFilter(30)

⇒ res0: kotlin.Int = 15

الخطوة 2: إنشاء دالة lambda للفلترة

1. في REPL، أنشئ فئة بيانات، Fish، تتضمّن سمة واحدة، name.

data class Fish(val name: String)

2. أنشئ قائمة تضم 3 Fish، مع الأسماء "فليبر" و"موبي ديك" و"دوري".

val myFish = listOf(Fish("Flipper"), Fish("Moby Dick"), Fish("Dory"))

3. أضِف فلترًا للبحث عن الأسماء التي تحتوي على الحرف "i".

myFish.filter { it.name.contains("i")}

⇒ res3: kotlin.collections.List<Line_1.Fish> = [Fish(name=Flipper), Fish(name=Moby Dick)]

في تعبير lambda، يشير it إلى عنصر القائمة الحالي، ويتم تطبيق الفلتر على كل عنصر من عناصر القائمة بالتسلسل.

4. طبِّق joinString() على النتيجة، باستخدام ", " كفاصل.

myFish.filter { it.name.contains("i")}.joinToString(", ") { it.name }

⇒ res4: kotlin.String = Flipper, Moby Dick

تنشئ الدالة joinToString() سلسلة من خلال ضم الأسماء التي تمّت فلترتها، مع الفصل بينها بالسلسلة المحدّدة. وهي إحدى الدوال المفيدة العديدة المضمّنة في مكتبة Kotlin العادية.

يؤدي تمرير lambda أو دالة أخرى كوسيطة إلى دالة إلى إنشاء دالة من الدرجة الأعلى. الفلتر أعلاه هو مثال بسيط على ذلك. ‫filter() هي دالة، وتمرِّر إليها تعبير lambda يحدّد كيفية معالجة كل عنصر من عناصر القائمة.

تُعد كتابة دوال من الدرجة العليا باستخدام تعبيرات lambda للدوال الإضافية من أكثر أجزاء لغة Kotlin تقدّمًا. قد يستغرق تعلُّم كيفية كتابتها بعض الوقت، ولكنّها مريحة جدًا للاستخدام.

الخطوة 1: إنشاء صف جديد

3. في حزمة example، أنشئ ملف Kotlin جديدًا باسم Fish.kt.
4. في Fish.kt، أنشئ فئة بيانات Fish، مع سمة واحدة، name.

data class Fish (var name: String)

5. أنشئ دالة fishExamples(). في fishExamples()، أنشئ سمكة باسم "splashy"، مع استخدام أحرف صغيرة فقط.

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
}

6. أنشئ الدالة main() التي تستدعي fishExamples().

fun main () {
    fishExamples()
}

6. يمكنك تجميع برنامجك وتشغيله من خلال النقر على المثلث الأخضر على يمين main(). لم يتم عرض أي نتائج بعد.

الخطوة 2: استخدام دالة من الدرجة الأعلى

تتيح لك الدالة with() إنشاء مرجع واحد أو أكثر إلى عنصر أو سمة بطريقة أكثر إيجازًا. استخدام this with() هي في الواقع دالة من الدرجة العليا، وفي lambda، تحدّد ما يجب فعله بالكائن المقدَّم.

1. استخدِم with() لكتابة اسم السمكة بأحرف كبيرة في fishExamples(). داخل الأقواس المتعرّجة، يشير this إلى العنصر الذي تم تمريره إلى with().

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        this.capitalize()
    }
}

2. لا يوجد ناتج، لذا أضِف println() حوله. وthis ضمني ولا حاجة إليه، لذا يمكنك إزالته.

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        println(capitalize())
    }
}

⇒ Splashy

الخطوة 3: إنشاء دالة من الرتبة الأعلى

في الخلفية، with() هي دالة من الدرجة العليا. لمعرفة طريقة عمل ذلك، يمكنك إنشاء نسخة مبسطة للغاية من with() تعمل فقط مع السلاسل.

1. في Fish.kt، حدِّد دالة myWith() تأخذ وسيطتَين. الوسيطتان هما الكائن الذي سيتم تنفيذ العملية عليه والدالة التي تحدّد العملية. اتّبِع التنسيق block عند تسمية الوسيطة في الدالة. في هذه الحالة، لا تعرض هذه الدالة أي قيمة، ويتم تحديد ذلك باستخدام Unit.

fun myWith(name: String, block: String.() -> Unit) {}

داخل myWith()، أصبحت block() الآن وظيفة إضافية في String. يُطلق على الفئة التي يتم توسيعها غالبًا اسم الكائن المستقبِل. إذًا name هو عنصر الاستقبال في هذه الحالة.

2. في نص الدالة myWith()، طبِّق الدالة التي تم تمريرها، block()، على عنصر المتلقّي، name.

fun myWith(name: String, block: String.() -> Unit) {
    name.block()
}

3. في fishExamples()، استبدِل with() بـ myWith().

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    myWith (fish.name) {
        println(capitalize())
    }
}

fish.name هي وسيطة الاسم، وprintln(capitalize()) هي دالة الحظر.

4. شغِّل البرنامج، وسيعمل كما كان من قبل.

⇒ Splashy

الخطوة 4: استكشاف المزيد من الإضافات المضمّنة

إنّ دالة lambda الخاصة بالإضافة with() مفيدة جدًا، وهي جزء من مكتبة Kotlin العادية. في ما يلي بعض الأدوات الأخرى التي قد تجدها مفيدة: run() وapply() وlet().

الدالة run() هي إضافة تعمل مع جميع الأنواع. تأخذ هذه الدالة تعبير lambda واحدًا كمعلَمة وتعرض نتيجة تنفيذ تعبير lambda.

1. في fishExamples()، اتّصِل بالرقم run() في fish للحصول على الاسم.

fish.run {
   name
}

تعرض هذه الدالة السمة name فقط. يمكنك تعيين ذلك إلى متغيّر أو طباعته. هذا ليس مثالاً مفيدًا في الواقع، إذ يمكنك الوصول إلى السمة مباشرةً، ولكن يمكن أن يكون run() مفيدًا للتعبيرات الأكثر تعقيدًا.

تشبه الدالة apply() الدالة run()، ولكنها تعرض العنصر الذي تم تغييره والذي تم تطبيقها عليه بدلاً من نتيجة دالة lambda. يمكن أن يكون ذلك مفيدًا لاستدعاء الطرق على كائن تم إنشاؤه حديثًا.

2. أنشئ نسخة من fish واستخدِم الدالة apply() لضبط اسم النسخة الجديدة.

val fish2 = Fish(name = "splashy").apply {
     name = "sharky"
}
println(fish2.name)

⇒ sharky

ملاحظة: run() وapply() متشابهتان، ولكن run() تعرض نتيجة تطبيق الدالة، بينما تعرض apply() العنصر بعد تطبيق الدالة.

تشبه الدالة let() الدالة apply()، ولكنّها تعرض نسخة من العنصر مع التغييرات. يمكن أن يكون ذلك مفيدًا لربط عمليات المعالجة معًا.

3. استخدِم let() للحصول على اسم fish، ثمّ اكتبه بأحرف كبيرة، وأضِف إليه سلسلة أخرى، واحصل على طول النتيجة، وأضِف 31 إلى الطول، ثمّ اطبع النتيجة.

println(fish.let { it.name.capitalize()}
.let{it + "fish"}
.let{it.length}
.let{it + 31})

⇒ 42

في هذا المثال، نوع العنصر الذي يشير إليه it هو Fish، ثم String، ثم String مرة أخرى، وأخيرًا Int.

4. اطبع fish بعد استدعاء let()، وسترى أنّه لم يتغيّر.

println(fish.let { it.name.capitalize()}
    .let{it + "fish"}
    .let{it.length}
    .let{it + 31})
println(fish)

⇒ 42
Fish(name=splashy)

تُعدّ دوال lambda والدوال ذات الترتيب الأعلى مفيدة جدًا، ولكن هناك أمر يجب معرفته: دوال lambda هي كائنات. تعبير lambda هو مثيل لواجهة Function، وهي نفسها نوع فرعي من Object. لنأخذ المثال السابق myWith().

myWith(fish.name) {
    capitalize()
}

تحتوي الواجهة Function على طريقة invoke() يتم تجاهلها لاستدعاء تعبير lambda. إذا كتبنا هذا الرمز بشكل كامل، سيبدو على النحو الموضّح أدناه.

// actually creates an object that looks like this
myWith(fish.name, object : Function1<String, Unit> {
    override fun invoke(name: String) {
        name.capitalize()
    }
})

لا يشكّل ذلك عادةً مشكلة، لأنّ إنشاء الكائنات واستدعاء الدوال لا يتطلّب الكثير من الموارد، أي الذاكرة ووقت وحدة المعالجة المركزية. ولكن إذا كنت تعرّف شيئًا مثل myWith() الذي تستخدمه في كل مكان، فقد تتراكم النفقات العامة.

توفّر لغة Kotlin inline كطريقة للتعامل مع هذه الحالة من أجل تقليل النفقات العامة أثناء وقت التشغيل عن طريق إضافة المزيد من العمل للمترجم. (تعرّفت على بعض المعلومات عن inline في الدرس السابق الذي تناول أنواع البيانات المادية). يشير وضع علامة inline على دالة إلى أنّه في كل مرة يتم فيها استدعاء الدالة، سيحوّل المترجم البرمجي رمز المصدر إلى "رمز مضمّن" للدالة. أي أنّ المترجم البرمجي سيغيّر الرمز لاستبدال تعبير lambda بالتعليمات الواردة فيه.

إذا تم وضع علامة inline على myWith() في المثال أعلاه:

inline myWith(fish.name) {
    capitalize()
}

يتم تحويلها إلى مكالمة مباشرة:

// with myWith() inline, this becomes
fish.name.capitalize()

يُرجى العِلم أنّ تضمين الدوال الكبيرة يؤدي إلى زيادة حجم الرمز البرمجي، لذا من الأفضل استخدام هذه الطريقة مع الدوال البسيطة التي يتم استخدامها عدة مرات، مثل myWith(). يتم وضع العلامة inline على دوال الإضافة من المكتبات التي تعرّفت عليها سابقًا، لذا لا داعي للقلق بشأن إنشاء عناصر إضافية.

يشير مصطلح Single Abstract Method إلى واجهة تتضمّن طريقة واحدة. وهي شائعة جدًا عند استخدام واجهات برمجة التطبيقات المكتوبة بلغة البرمجة Java، لذا يوجد اختصار لها، وهو SAM. بعض الأمثلة على ذلك هي Runnable التي تتضمّن طريقة مجرّدة واحدة، وrun()، وCallable التي تتضمّن طريقة مجرّدة واحدة، وcall().

في Kotlin، عليك استدعاء الدوال التي تستخدم SAMs كمعلّمات طوال الوقت. جرِّب المثال أدناه.

1. داخل example، أنشئ فئة Java، JavaRun، والصِق ما يلي في الملف.

package example;

public class JavaRun {
    public static void runNow(Runnable runnable) {
        runnable.run();
    }
}

تتيح لك لغة Kotlin إنشاء مثيل لكائن ينفّذ واجهة من خلال إضافة object: قبل النوع. وهي مفيدة لتمرير المَعلمات إلى SAM.

2. في Fish.kt، أنشئ الدالة runExample() التي تنشئ Runnable باستخدام object: يجب أن ينفّذ الكائن run() من خلال طباعة "I'm a Runnable".

fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
}

3. استدعِ الدالة JavaRun.runNow() باستخدام العنصر الذي أنشأته.

fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
    JavaRun.runNow(runnable)
}

4. اتّصِل بالرقم runExample() من الرقم main() وشغِّل البرنامج.

⇒ I'm a Runnable

يتطلّب طباعة شيء ما الكثير من العمل، ولكنّه مثال جيد على طريقة عمل SAM. بالطبع، توفّر Kotlin طريقة أبسط لإجراء ذلك، وهي استخدام تعبير lambda بدلاً من العنصر لجعل هذا الرمز أكثر إيجازًا.

4. أزِل الرمز الحالي في runExample، وغيِّره لاستدعاء runNow() باستخدام تعبير lambda، ثم شغِّل البرنامج.

fun runExample() {
    JavaRun.runNow({
        println("Passing a lambda as a Runnable")
    })
}

⇒ Passing a lambda as a Runnable

5. يمكنك جعل هذا أكثر اختصارًا باستخدام بنية استدعاء المَعلمة الأخيرة، والتخلّص من الأقواس.

fun runExample() {
    JavaRun.runNow {
        println("Last parameter is a lambda as a Runnable")
    }
}

⇒ Last parameter is a lambda as a Runnable

هذه هي أساسيات SAM، أي طريقة مجردة واحدة. يمكنك إنشاء مثيل لـ SAM وتجاوزه وإجراء مكالمة إليه باستخدام سطر واحد من الرمز، وذلك باستخدام النمط:
Class.singleAbstractMethod { lambda_of_override }

راجَع هذا الدرس تعبيرات lambda وتناول بالتفصيل الدوال ذات الترتيب الأعلى، وهي أجزاء أساسية من Kotlin. تعرّفت أيضًا على التعليقات التوضيحية وفواصل الأغاني المصنّفة.

• استخدِم التعليقات التوضيحية لتحديد العناصر التي يجب أن ينفّذها المترجم. على سبيل المثال:
  @file:JvmName("Foo")
• استخدِم عبارات break مصنّفة للسماح للرمز البرمجي بالخروج من داخل الحلقات المتداخلة. على سبيل المثال:
  if (i > 10) break@outerLoop // breaks to outerLoop label
• يمكن أن تكون تعابير Lambda فعّالة جدًا عند استخدامها مع دوال من الرتبة العليا.
• التعابير اللامدا هي كائنات. لتجنُّب إنشاء العنصر، يمكنك وضع علامة inline على الدالة، وسيضع المترجم محتوى تعبير lambda في الرمز مباشرةً.
• استخدِم inline بحذر، ولكن يمكن أن يساعد في تقليل استخدام الموارد من خلال برنامجك.
• ‫SAM، أي Single Abstract Method، هو نمط شائع، وأصبح أبسط مع تعبيرات lambda. النمط الأساسي هو:
  Class.singleAbstractMethod { lamba_of_override }
• توفّر مكتبة Kotlin العادية العديد من الدوال المفيدة، بما في ذلك العديد من واجهات SAM، لذا ننصحك بالتعرّف على محتواها.

هناك الكثير من المعلومات حول Kotlin لم يتم تناولها في الدورة التدريبية، ولكن لديك الآن الأساسيات لبدء تطوير برامج Kotlin الخاصة بك. نأمل أن تكون متحمّسًا لهذه اللغة التعبيرية، وأن تتطلّع إلى إنشاء المزيد من الوظائف مع كتابة تعليمات برمجية أقل (خاصةً إذا كنت تستخدم لغة البرمجة Java). إنّ الممارسة والتعلم أثناء العمل هما أفضل طريقة لتصبح خبيرًا في Kotlin، لذا ننصحك بمواصلة استكشاف Kotlin والتعرّف عليها بنفسك.

مستندات Kotlin

إذا أردت الحصول على مزيد من المعلومات حول أي موضوع في هذه الدورة التدريبية، أو إذا واجهتك أي مشكلة، يمكنك الانتقال إلى https://kotlinlang.org.

• اتّباع أسلوب الترميز في Kotlin
• عبارات Kotlin الشائعة

• التعليقات التوضيحية
• التفكير مليًا
• فواصل مصنَّفة
• الدوال ذات الترتيب الأعلى وlambdas
• الدوال المضمّنة

برامج تعليمية حول Kotlin

يتضمّن الموقع الإلكتروني https://try.kotlinlang.org برامج تعليمية غنية بصريًا تُعرف باسم Kotlin Koans، ومترجم مستند إلى الويب، ومجموعة كاملة من المستندات المرجعية مع أمثلة.

دورة Udacity التدريبية

للاطّلاع على دورة Udacity التدريبية حول هذا الموضوع، يُرجى الانتقال إلى برنامج Kotlin التدريبي للمبرمجين.

IntelliJ IDEA

يمكنك العثور على مستندات IntelliJ IDEA على موقع JetBrains الإلكتروني.

مكتبة Kotlin المعيارية

توفّر مكتبة Kotlin العادية العديد من الدوال المفيدة. قبل كتابة دالة أو واجهة خاصة بك، تحقَّق دائمًا من "المكتبة العادية" لمعرفة ما إذا كان أحد المستخدمين قد وفّر عليك بعض العمل. يُرجى التحقّق من هذه الصفحة من حين لآخر، لأنّنا نضيف وظائف جديدة بشكل متكرّر.

برامج تعليمية حول Kotlin

يتضمّن الموقع الإلكتروني https://try.kotlinlang.org برامج تعليمية غنية بصريًا تُعرف باسم Kotlin Koans، ومترجم مستند إلى الويب، ومجموعة كاملة من المستندات المرجعية مع أمثلة.

دورة Udacity التدريبية

للاطّلاع على دورة Udacity التدريبية حول هذا الموضوع، يُرجى الانتقال إلى برنامج Kotlin التدريبي للمبرمجين.

IntelliJ IDEA

يمكنك العثور على مستندات IntelliJ IDEA على موقع JetBrains الإلكتروني.

يسرد هذا القسم مهامًا منزلية محتملة للطلاب الذين يعملون على هذا الدرس التطبيقي العملي كجزء من دورة تدريبية يقودها مدرّب. على المعلّم تنفيذ ما يلي:

• حدِّد واجبًا منزليًا إذا لزم الأمر.
• توضيح كيفية إرسال الواجبات المنزلية للطلاب
• وضع درجات للواجبات المنزلية

يمكن للمدرّبين استخدام هذه الاقتراحات بالقدر الذي يريدونه، ويجب ألا يترددوا في تكليف الطلاب بأي واجبات منزلية أخرى يرونها مناسبة.

إذا كنت تعمل على هذا الدرس العملي بنفسك، يمكنك استخدام مهام الواجب المنزلي هذه لاختبار معلوماتك.

الإجابة عن هذه الأسئلة

السؤال 1

في لغة Kotlin، يشير الاختصار SAM إلى:

‫▢ مطابقة الوسيطات الآمنة

‫▢ طريقة الوصول البسيط

‫▢ Single Abstract Method

‫▢ منهجية الوصول الاستراتيجي

السؤال 2

أيّ مما يلي ليس دالة إضافية في مكتبة Kotlin العادية؟

▢ elvis()

▢ apply()

▢ run()

▢ with()

السؤال 3

أيّ مما يلي غير صحيح بشأن تعبيرات lambda في Kotlin؟

▢ دوال Lambda هي دوال مجهولة الهوية.

▢ تكون الدوال اللامدا كائنات ما لم يتم تضمينها.

▢ تتطلّب دوال Lambda الكثير من الموارد ويجب عدم استخدامها.

▢ يمكن تمرير تعبيرات lambda إلى دوال أخرى.

السؤال 4

يتم الإشارة إلى التصنيفات في Kotlin باستخدام معرّف متبوعًا بما يلي:

▢ :

▢ ::

▢ @:

▢ @

تهانينا! لقد أكملت الدرس التطبيقي حول الترميز "برنامج تدريبي مكثّف حول لغة Kotlin للمبرمجين".

للحصول على نظرة عامة على الدورة التدريبية، بما في ذلك روابط تؤدي إلى دروس تطبيقية أخرى حول الترميز، يُرجى الاطّلاع على "برنامج Kotlin التدريبي للمبرمجين: مرحبًا بك في الدورة التدريبية".