این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.

Kotlin Bootcamp برای برنامه نویسان 6: دستکاری عملکردی

این کد لبه بخشی از دوره Kotlin Bootcamp برای برنامه نویسان است. اگر به ترتیب روی کدها کار کنید، بیشترین ارزش را از این دوره خواهید گرفت. بسته به دانش خود، ممکن است بتوانید برخی از بخش ها را مرور کنید. این دوره مختص برنامه نویسانی است که یک زبان شی گرا را می دانند و می خواهند Kotlin را یاد بگیرند.

مقدمه

این آخرین کد لبه در بوت کمپ Kotlin است. در این کد لبه با حاشیه نویسی و شکست های برچسب دار آشنا می شوید. شما لامبداها و توابع درجه بالاتر را که بخش‌های کلیدی Kotlin هستند، مرور می‌کنید. همچنین در مورد توابع درون خطی و رابط های روش انتزاعی منفرد (SAM) اطلاعات بیشتری کسب خواهید کرد. در نهایت، درباره کتابخانه استاندارد کاتلین اطلاعات بیشتری کسب می کنید.

به جای ساختن یک برنامه نمونه واحد، درس‌های این دوره برای ایجاد دانش شما طراحی شده‌اند، اما نیمه مستقل از یکدیگر باشند تا بتوانید بخش‌هایی را که با آن‌ها آشنا هستید، مرور کنید. برای گره زدن آنها به یکدیگر، بسیاری از نمونه ها از تم آکواریوم استفاده می کنند. و اگر می خواهید داستان کامل آکواریوم را ببینید، دوره Kotlin Bootcamp for Programmers Udacity را بررسی کنید.

آنچه از قبل باید بدانید

نحو توابع، کلاس ها و متدهای کاتلین
نحوه ایجاد یک کلاس جدید در IntelliJ IDEA و اجرای یک برنامه
اصول لامبدا و توابع درجه بالاتر

چیزی که یاد خواهید گرفت

مبانی حاشیه نویسی
نحوه استفاده از شکست های برچسب دار
اطلاعات بیشتر در مورد توابع مرتبه بالاتر
درباره رابط های روش انتزاعی منفرد (SAM).
درباره کتابخانه استاندارد کاتلین

کاری که خواهی کرد

یک حاشیه نویسی ساده ایجاد کنید.
از یک استراحت با برچسب استفاده کنید.
بررسی توابع لامبدا در کاتلین.
از توابع درجه بالاتر استفاده و ایجاد کنید.
برخی از رابط های Single Abstract Method را فراخوانی کنید.
از برخی توابع کتابخانه استاندارد کاتلین استفاده کنید.

حاشیه نویسی راهی برای پیوست کردن ابرداده به کد است و چیزی خاص برای Kotlin نیست. حاشیه نویسی توسط کامپایلر خوانده می شود و برای تولید کد یا منطق استفاده می شود. بسیاری از فریم‌ورک‌ها، مانند Ktor و Kotlinx ، و همچنین Room ، از حاشیه‌نویسی برای پیکربندی نحوه اجرا و تعامل با کد شما استفاده می‌کنند. تا زمانی که شروع به استفاده از چارچوب ها نکنید، بعید به نظر می رسد که با حاشیه نویسی روبرو شوید، اما این مفید است که بتوانید یادداشت را بخوانید.

همچنین حاشیه نویسی هایی وجود دارد که از طریق کتابخانه استاندارد Kotlin موجود است که نحوه کامپایل کد را کنترل می کند. اگر Kotlin را به کد جاوا صادر می کنید، آنها واقعا مفید هستند، اما در غیر این صورت اغلب به آنها نیاز ندارید.

حاشیه نویسی ها درست قبل از چیزی که حاشیه نویسی می شود قرار می گیرند و بیشتر چیزها را می توان حاشیه نویسی کرد - کلاس ها، توابع، روش ها و حتی ساختارهای کنترلی. برخی از حاشیه نویسی ها می توانند استدلال کنند.

در اینجا نمونه ای از حاشیه نویسی ها آورده شده است.

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

این می گوید که نام صادر شده این فایل InteropFish با حاشیه نویسی JvmName است. حاشیه نویسی JvmName آرگومان "InteropFish" را می گیرد. در شیء همراه، @JvmStatic به کاتلین می‌گوید که interop() به یک تابع ثابت در InteropFish تبدیل کند.

همچنین می‌توانید حاشیه‌نویسی‌های خود را ایجاد کنید، اما اگر کتابخانه‌ای می‌نویسید که به اطلاعات خاصی در مورد کلاس‌ها در زمان اجرا نیاز دارد، این کار بیشتر مفید است.

مرحله 1: یک بسته و فایل جدید ایجاد کنید

در زیر src ، یک بسته جدید ایجاد کنید، example .
به عنوان مثال ، یک فایل Kotlin جدید، Annotations.kt ایجاد کنید.

مرحله 2: حاشیه نویسی خود را ایجاد کنید

در Annotations.kt یک کلاس Plant با دو متد trim() و fertilize() ایجاد کنید.

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

تابعی ایجاد کنید که تمام متدهای یک کلاس را چاپ کند. از ::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)
    }
}

یک تابع main() برای فراخوانی روال تست خود ایجاد کنید. برنامه خود را اجرا کنید و خروجی را مشاهده کنید.

fun main() {
    testAnnotations()
}

⇒ trim
fertilize

یک حاشیه نویسی ساده ایجاد کنید، ImAPlant .

annotation class ImAPlant

این هیچ کار دیگری انجام نمی دهد جز اینکه بگوید حاشیه نویسی شده است.

حاشیه نویسی را در مقابل کلاس Plant خود اضافه کنید.

@ImAPlant class Plant{
    ...
}

برای چاپ تمام حاشیه نویسی های یک کلاس، testAnnotations() تغییر دهید. annotations برای دریافت تمام حاشیه نویسی های یک کلاس استفاده کنید. برنامه خود را اجرا کنید و نتیجه را مشاهده کنید.

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

⇒ ImAPlant

برای یافتن حاشیه نویسی ImAPlant testAnnotations() تغییر دهید. از findAnnotation() برای یافتن یک حاشیه نویسی خاص استفاده کنید. برنامه خود را اجرا کنید و نتیجه را مشاهده کنید.

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

⇒ @example.ImAPlant()

مرحله 3: یک حاشیه نویسی هدفمند ایجاد کنید

حاشیه نویسی ها می توانند گیرندگان یا تنظیم کننده ها را هدف قرار دهند. وقتی آنها این کار را انجام دادند، می توانید آنها را با پیشوند @get: یا @set: اعمال کنید. این موضوع هنگام استفاده از فریم ورک‌های دارای حاشیه‌نویسی زیاد به چشم می‌خورد.

دو حاشیه نویسی، 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
}

حاشیه نویسی ها برای ایجاد کتابخانه هایی که موارد را هم در زمان اجرا و هم گاهی در زمان کامپایل بررسی می کنند، واقعا قدرتمند هستند. با این حال، کد برنامه معمولی فقط از حاشیه نویسی ارائه شده توسط چارچوب ها استفاده می کند.

کاتلین راه های مختلفی برای کنترل جریان دارد. شما قبلاً با return آشنا هستید که از یک تابع به تابع احاطه کننده آن برمی گردد. استفاده از break مانند return است، اما برای حلقه ها.

Kotlin به شما کنترل بیشتری روی حلقه‌ها می‌دهد که به آن شکست برچسب‌گذاری شده می‌گویند. یک break واجد شرایط با برچسب درست پس از حلقه مشخص شده با آن برچسب به نقطه اجرا می‌رود. این به ویژه هنگام برخورد با حلقه های تو در تو مفید است.

هر عبارتی در Kotlin ممکن است با یک برچسب مشخص شود. برچسب ها به شکل یک شناسه و به دنبال آن علامت @ هستند.

در Annotations.kt ، یک شکست برچسب‌دار را با شکستن از یک حلقه داخلی امتحان کنید.

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()
}

برنامه خود را اجرا کنید و خروجی را مشاهده کنید.

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

به طور مشابه، می توانید از برچسب continue استفاده کنید. به جای شکستن از حلقه برچسب‌گذاری شده، ادامه برچسب‌دار به تکرار بعدی حلقه ادامه می‌دهد.

لامبداها توابع ناشناس هستند که توابعی بدون نام هستند. می توانید آنها را به متغیرها اختصاص دهید و آنها را به عنوان آرگومان به توابع و متدها ارسال کنید. آنها فوق العاده مفید هستند.

مرحله 1: یک لامبدا ساده بسازید

REPL را در IntelliJ IDEA، Tools > Kotlin > Kotlin REPL شروع کنید.
ایجاد یک لامبدا با آرگومان، dirty: Int که یک محاسبه را انجام می‌دهد و dirty بر 2 تقسیم می‌کند. لامبدا را به یک متغیر، waterFilter اختصاص دهید.

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

با عبور از مقدار 30، waterFilter فراخوانی کنید.

waterFilter(30)

⇒ res0: kotlin.Int = 15

مرحله 2: یک فیلتر لامبدا ایجاد کنید

هنوز در REPL، یک کلاس داده، Fish ، با یک ویژگی، name ایجاد کنید.

data class Fish(val name: String)

یک لیست از 3 Fish با نام های Flipper، Moby Dick و Dory ایجاد کنید.

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

برای بررسی اسامی حاوی حرف "i" یک فیلتر اضافه کنید.

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

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

در عبارت lambda، به عنصر لیست فعلی اشاره it و فیلتر به نوبه خود برای هر عنصر لیست اعمال می شود.

joinString() با استفاده از ", " به عنوان جداکننده به نتیجه اعمال کنید.

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

⇒ res4: kotlin.String = Flipper, Moby Dick

تابع joinToString() یک رشته با پیوستن به نام های فیلتر شده ایجاد می کند که با رشته مشخص شده از هم جدا شده اند. این یکی از بسیاری از توابع مفید است که در کتابخانه استاندارد Kotlin تعبیه شده است.

ارسال یک لامبدا یا تابع دیگر به عنوان آرگومان به یک تابع، یک تابع مرتبه بالاتر ایجاد می کند. فیلتر بالا یک مثال ساده از این مورد است. filter() یک تابع است و شما آن را به صورت لامبدا ارسال می کنید که نحوه پردازش هر عنصر لیست را مشخص می کند.

نوشتن توابع درجه بالاتر با پسوند لامبدا یکی از پیشرفته ترین بخش های زبان کاتلین است. یادگیری نحوه نوشتن آنها مدتی طول می کشد، اما استفاده از آنها واقعا راحت است.

مرحله 1: یک کلاس جدید ایجاد کنید

در بسته نمونه ، یک فایل Kotlin جدید، Fish.kt ایجاد کنید.
در Fish.kt ، یک کلاس داده Fish ، با یک ویژگی، name ایجاد کنید.

data class Fish (var name: String)

یک تابع fishExamples() ایجاد کنید. در fishExamples() یک ماهی به نام "splashy" ایجاد کنید که همگی با حروف کوچک است.

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

یک تابع main() ایجاد کنید که fishExamples() را فراخوانی کند.

fun main () {
    fishExamples()
}

با کلیک بر روی مثلث سبز رنگ سمت چپ main() برنامه خود را کامپایل و اجرا کنید. هنوز خروجی وجود ندارد.

مرحله 2: از یک تابع مرتبه بالاتر استفاده کنید

تابع with() به شما امکان می دهد یک یا چند ارجاع به یک شی یا ویژگی را به روشی فشرده تر انجام دهید. با استفاده از this . with() در واقع یک تابع مرتبه بالاتر است و در lamba مشخص می کنید که با شی ارائه شده چه کاری انجام دهید.

with() برای بزرگ کردن نام ماهی در fishExamples() استفاده کنید. در داخل پرانتزهای فرفری، this به شیء ارسال شده به with() اشاره دارد.

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

هیچ خروجی وجود ندارد، بنابراین یک println() در اطراف آن اضافه کنید. و this ضمنی است و مورد نیاز نیست، بنابراین می توانید آن را حذف کنید.

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

⇒ Splashy

مرحله 3: یک تابع مرتبه بالاتر ایجاد کنید

زیر هود، with() یک تابع درجه بالاتر است. برای اینکه ببینید چگونه این کار می کند، می توانید نسخه بسیار ساده شده خود را with() بسازید که فقط برای رشته ها کار می کند.

در Fish.kt یک تابع به myWith() تعریف کنید که دو آرگومان می گیرد. آرگومان ها شیئی هستند که باید روی آنها عمل کرد و تابعی هستند که عملیات را تعریف می کنند. قرارداد نام آرگومان با تابع block است. در این حالت، آن تابع چیزی را برمی گرداند که با Unit مشخص شده است.

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

در داخل myWith() ، block() اکنون یک تابع پسوندی از String است. کلاسی که در حال گسترش است اغلب شی گیرنده نامیده می شود. بنابراین name در این مورد شی گیرنده است.

در بدنه myWith() ، تابع ارسال شده، block() را به شی گیرنده، name اعمال کنید.

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

در fishExamples() with() myWith() جایگزین کنید.

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

fish.name آرگومان نام است و println(capitalize()) تابع بلوک است.

برنامه را اجرا کنید، و مانند قبل عمل می کند.

⇒ Splashy

مرحله 4: افزونه های داخلی بیشتر را کاوش کنید

پسوند with() lambda بسیار مفید است و بخشی از کتابخانه استاندارد Kotlin است. در اینجا چند مورد دیگر وجود دارد که ممکن است مفید باشید: run() ، apply() و let() .

تابع run() پسوندی است که با همه انواع کار می کند. یک لامبدا را به عنوان آرگومان خود می گیرد و نتیجه اجرای لامبدا را برمی گرداند.

در fishExamples() برای دریافت نام، run() را روی fish فراخوانی کنید.

fish.run {
   name
}

این فقط ویژگی name را برمی گرداند. می توانید آن را به یک متغیر اختصاص دهید یا آن را چاپ کنید. این در واقع یک مثال مفید نیست، زیرا شما فقط می توانید به ویژگی دسترسی داشته باشید، اما run() می تواند برای عبارات پیچیده تر مفید باشد.

تابع apply() شبیه run() است، اما به جای نتیجه لامبدا، شی تغییر یافته ای را که به آن اعمال شده است، برمی گرداند. این می تواند برای فراخوانی متدها بر روی یک شی تازه ایجاد شده مفید باشد.

یک کپی از fish تهیه کنید و برای تنظیم نام کپی جدید، apply() را فراخوانی کنید.

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

⇒ sharky

تابع let() شبیه به apply() است، اما یک کپی از شی را با تغییرات برمی گرداند. این می تواند برای زنجیره زدن دستکاری ها با هم مفید باشد.

از let() برای به دست آوردن نام fish استفاده کنید، آن را با حروف بزرگ بنویسید، رشته دیگری را به آن الحاق کنید، طول آن نتیجه را بگیرید، 31 را به طول اضافه کنید، سپس نتیجه را چاپ کنید.

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

⇒ 42

در این مثال، نوع شی مورد it Fish ، سپس String ، سپس String دوباره و در نهایت Int است.

پس از فراخوانی let() fish چاپ کنید و خواهید دید که تغییری نکرده است.

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

⇒ 42
Fish(name=splashy)

لامبداها و توابع درجه بالاتر واقعاً مفید هستند، اما چیزی وجود دارد که باید بدانید: لامبداها اشیا هستند. عبارت لامبدا نمونه‌ای از رابط Function است که خود زیرگروهی از Object است. مثال قبلی myWith() را در نظر بگیرید.

myWith(fish.name) {
    capitalize()
}

اینترفیس Function دارای یک متد invoke() است که برای فراخوانی عبارت لامبدا رد شده است. به صورت طولانی نوشته شده باشد، چیزی شبیه به کد زیر است.

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

معمولاً این مشکلی نیست، زیرا ایجاد اشیاء و فراخوانی توابع هزینه زیادی را متحمل نمی شود، یعنی زمان حافظه و CPU. اما اگر چیزی مانند myWith() تعریف می‌کنید که در همه جا از آن استفاده می‌کنید، سربار می‌تواند اضافه شود.

Kotlin inline به عنوان راهی برای رسیدگی به این مورد برای کاهش سربار در طول زمان اجرا با اضافه کردن کمی کار بیشتر برای کامپایلر فراهم می‌کند. (شما در درس قبلی که در مورد انواع reified صحبت می کردیم، اندکی در مورد inline یاد گرفتید.) علامت گذاری یک تابع به عنوان inline به این معنی است که هر بار که تابع فراخوانی می شود، کامپایلر در واقع کد منبع را به "inline" تابع تبدیل می کند. یعنی کامپایلر کد را تغییر می دهد تا دستورات داخل لامبدا را جایگزین لامبدا کند.

اگر myWith() در مثال بالا با inline مشخص شده باشد:

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

به یک تماس مستقیم تبدیل می شود:

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

شایان ذکر است که داخل کردن توابع بزرگ اندازه کد شما را افزایش می دهد، بنابراین بهتر است برای توابع ساده ای که بارها مانند myWith() استفاده می شوند استفاده شود. توابع برنامه افزودنی از کتابخانه هایی که قبلاً در مورد آنها یاد گرفتید به inline علامت گذاری شده اند، بنابراین لازم نیست نگران ایجاد اشیاء اضافی باشید.

Single Abstract Method فقط به معنای یک رابط با یک روش در آن است. آنها هنگام استفاده از APIهای نوشته شده در زبان برنامه نویسی جاوا بسیار رایج هستند، بنابراین مخفف آن SAM وجود دارد. برخی از مثال‌ها عبارتند از Runnable که دارای یک متد انتزاعی واحد، run() و Callable است که دارای یک متد انتزاعی منفرد، call() است.

در Kotlin، شما باید توابعی را فراخوانی کنید که SAM ها را همیشه به عنوان پارامتر می گیرند. مثال زیر را امتحان کنید.

به عنوان مثال ، یک کلاس جاوا، JavaRun ایجاد کنید و موارد زیر را در فایل قرار دهید.

package example;

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

Kotlin به شما امکان می دهد یک شی را که یک رابط را با قبل از تایپ با object: . برای انتقال پارامترها به SAM مفید است.

در Fish.kt ، یک تابع runExample() ایجاد کنید، که یک Runnable با استفاده از object: شی باید run() با چاپ "I'm a Runnable" پیاده سازی کند.

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

JavaRun.runNow() را با شی ای که ایجاد کردید فراخوانی کنید.

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

runExample() از main() فراخوانی کرده و برنامه را اجرا کنید.

⇒ I'm a Runnable

کار زیادی برای چاپ کردن چیزی است، اما نمونه خوبی از نحوه کار SAM است. البته، کاتلین راه ساده‌تری برای انجام این کار ارائه می‌دهد - از یک لامبدا به جای شی استفاده کنید تا این کد بسیار فشرده‌تر شود.

کد موجود در runExample را حذف کنید، آن را با یک لامبدا به runNow() تغییر دهید و برنامه را اجرا کنید.

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

⇒ Passing a lambda as a Runnable

می‌توانید با استفاده از آخرین نحو فراخوانی پارامتر، این را مختصرتر کنید و از شر پرانتز خلاص شوید.

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 }

این درس لامبداها را مرور کرد و با توابع درجه بالاتر - بخش‌های کلیدی کاتلین - به عمق بیشتری رفت. همچنین درباره حاشیه‌نویسی‌ها و وقفه‌های برچسب‌گذاری‌شده یاد گرفتید.

از حاشیه نویسی برای مشخص کردن موارد برای کامپایلر استفاده کنید. به عنوان مثال:
@file:JvmName("Foo")
برای خروج کدتان از داخل حلقه های تو در تو، از شکست های برچسب دار استفاده کنید. به عنوان مثال:
if (i > 10) break@outerLoop // breaks to outerLoop label
لامبدا زمانی که با توابع درجه بالاتر همراه شود می تواند بسیار قدرتمند باشد.
لامبداها اشیا هستند. برای جلوگیری از ایجاد شی، می توانید تابع را با inline علامت گذاری کنید و کامپایلر محتوای لامبدا را مستقیماً در کد قرار می دهد.
inline با دقت استفاده کنید، اما می تواند به کاهش استفاده از منابع توسط برنامه شما کمک کند.
SAM، روش انتزاعی منفرد، یک الگوی رایج است و با لامبدا ساده‌تر شده است. الگوی اصلی این است:
Class.singleAbstractMethod { lamba_of_override }
کتابخانه استاندارد Kotlin عملکردهای مفید متعددی از جمله چندین SAM را ارائه می دهد، بنابراین با آنچه در آن است آشنا شوید.

چیزهای بیشتری در مورد Kotlin از آنچه در این دوره توضیح داده شد وجود دارد، اما شما اکنون اصول اولیه برای شروع توسعه برنامه های Kotlin خود را دارید. امیدواریم که در مورد این زبان رسا هیجان زده باشید و مشتاقانه منتظر ایجاد قابلیت های بیشتر در عین نوشتن کد کمتر هستید (مخصوصاً اگر از زبان برنامه نویسی جاوا می آیید.) تمرین و یادگیری بهترین راه برای تبدیل شدن به یک متخصص در Kotlin است، بنابراین خودتان به کاوش و یادگیری در مورد Kotlin ادامه دهید.

مستندات کاتلین

اگر در مورد هر موضوعی در این دوره اطلاعات بیشتری می خواهید، یا اگر گیر کرده اید، https://kotlinlang.org بهترین نقطه شروع شما است.

آموزش های کاتلین

وب‌سایت https://try.kotlinlang.org شامل آموزش‌های غنی به نام Kotlin Koans، یک مترجم مبتنی بر وب ، و مجموعه کاملی از مستندات مرجع با مثال‌ها است.

دوره جسارت

برای مشاهده دوره Udacity در مورد این موضوع، به Kotlin Bootcamp for Programmers مراجعه کنید.

ایده IntelliJ

اسناد IntelliJ IDEA را می توان در وب سایت JetBrains یافت.

کتابخانه استاندارد کاتلین

کتابخانه استاندارد کاتلین عملکردهای مفید متعددی را ارائه می دهد. قبل از اینکه عملکرد یا رابط کاربری خود را بنویسید، همیشه کتابخانه استاندارد را بررسی کنید تا ببینید آیا کسی کار شما را ذخیره کرده است یا خیر. گاهی اوقات دوباره بررسی کنید، زیرا عملکردهای جدید اغلب اضافه می شود.

آموزش های کاتلین

دوره جسارت

برای مشاهده دوره Udacity در مورد این موضوع، به Kotlin Bootcamp for Programmers مراجعه کنید.

ایده IntelliJ

اسناد IntelliJ IDEA را می توان در وب سایت JetBrains یافت.

این بخش، تکالیف احتمالی را برای دانش‌آموزانی که در این آزمایشگاه کد به عنوان بخشی از دوره‌ای که توسط یک مربی هدایت می‌شود، کار می‌کنند، فهرست می‌کند. این وظیفه مربی است که موارد زیر را انجام دهد:

در صورت نیاز تکالیف را تعیین کنید.
نحوه ارسال تکالیف را با دانش آموزان در میان بگذارید.
تکالیف را نمره دهید.

مربیان می‌توانند از این پیشنهادات به اندازه‌ای که می‌خواهند استفاده کنند، و باید با خیال راحت هر تکلیف دیگری را که فکر می‌کنند مناسب است، محول کنند.

اگر به تنهایی از طریق این کدها کار می کنید، از این تکالیف برای آزمایش دانش خود استفاده کنید.

به این سوالات پاسخ دهید

سوال 1

در کاتلین، SAM مخفف عبارت زیر است:

▢ تطبیق استدلال ایمن

▢ روش دسترسی ساده

▢ روش منفرد چکیده

▢ روش دسترسی استراتژیک

سوال 2

کدام یک از موارد زیر تابع افزونه کتابخانه استاندارد کاتلین نیست؟

▢ elvis()

▢ apply()

▢ run()

▢ with()

سوال 3

کدام یک از موارد زیر در مورد لامبدا در کاتلین صادق نیست؟

▢ لامبداها توابع ناشناس هستند.

▢ لامبدا اشیایی هستند مگر اینکه خطی شده باشند.

▢ لامبداها منابع فشرده هستند و نباید استفاده شوند.

▢ Lambdas را می توان به توابع دیگر منتقل کرد.

سوال 4

برچسب ها در Kotlin با یک شناسه و به دنبال آن نشان داده می شوند:

▢ :

▢ ::

▢ @:

▢ @

تبریک می گویم! شما Lab کد Kotlin Bootcamp for Programmers را تکمیل کرده اید.

برای یک نمای کلی از دوره، از جمله پیوندهایی به دیگر کدها، به "کوتلین بوت کمپ برای برنامه نویسان: به دوره خوش آمدید" مراجعه کنید.

Kotlin Bootcamp برای برنامه نویسان 6: دستکاری عملکردی با مجموعه‌ها، منظم بمانید ذخیره و طبقه‌بندی محتوا براساس اولویت‌های شما.

مقدمه

آنچه از قبل باید بدانید

چیزی که یاد خواهید گرفت

کاری که خواهی کرد

مرحله 1: یک بسته و فایل جدید ایجاد کنید

مرحله 2: حاشیه نویسی خود را ایجاد کنید

مرحله 3: یک حاشیه نویسی هدفمند ایجاد کنید

مرحله 1: یک لامبدا ساده بسازید

مرحله 2: یک فیلتر لامبدا ایجاد کنید

مرحله 1: یک کلاس جدید ایجاد کنید

مرحله 2: از یک تابع مرتبه بالاتر استفاده کنید

مرحله 3: یک تابع مرتبه بالاتر ایجاد کنید

مرحله 4: افزونه های داخلی بیشتر را کاوش کنید

مستندات کاتلین

آموزش های کاتلین

دوره جسارت

ایده IntelliJ

کتابخانه استاندارد کاتلین

آموزش های کاتلین

دوره جسارت

ایده IntelliJ

به این سوالات پاسخ دهید

سوال 1

سوال 2

سوال 3

سوال 4

Kotlin Bootcamp برای برنامه نویسان 6: دستکاری عملکردی