דף זה תורגם על ידי Cloud Translation API.

Kotlin Bootcamp for Programmers 6: Functional manipulation

ה-codelab הזה הוא חלק מקורס Kotlin Bootcamp for Programmers. כדי להפיק את המרב מהקורס הזה, מומלץ לעבוד על ה-codelabs לפי הסדר. אם יש לכם ידע בנושא, יכול להיות שתוכלו לדלג על חלק מהקטעים. הקורס הזה מיועד למתכנתים שמכירים שפה מונחית-אובייקטים ורוצים ללמוד Kotlin.

מבוא

זוהי סדנת ה-codelab האחרונה בסדנת Kotlin. ב-codelab הזה תלמדו על הערות ועל הפסקות עם תוויות. אתם בודקים פונקציות למדא ופונקציות מסדר גבוה, שהן חלקים מרכזיים ב-Kotlin. בנוסף, תוכלו לקרוא מידע נוסף על פונקציות מוטמעות ועל ממשקי Single Abstract Method ‏ (SAM). בסוף, תוכלו לקרוא מידע נוסף על הספרייה הסטנדרטית של Kotlin.

במקום ליצור אפליקציה לדוגמה אחת, השיעורים בקורס הזה נועדו להרחיב את הידע שלכם, אבל הם גם עצמאיים למחצה, כך שתוכלו לדלג על חלקים שאתם מכירים. כדי לקשור בין הדוגמאות, רבות מהן מתבססות על נושא האקווריום. אם אתם רוצים לראות את הסיפור המלא של האקווריום, כדאי לעיין בקורס Kotlin Bootcamp for Programmers ב-Udacity.

מה שכדאי לדעת

התחביר של פונקציות, מחלקות ושיטות ב-Kotlin
איך יוצרים כיתה חדשה ב-IntelliJ IDEA ומריצים תוכנית
הסבר בסיסי על פונקציות למבדה ופונקציות מסדר גבוה

מה תלמדו

מידע בסיסי על הערות
איך משתמשים בהפסקות עם תוויות
מידע נוסף על פונקציות מסדר גבוה
מידע על ממשקי 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: יוצרים חבילה וקובץ חדשים

בקטע 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

משנים את testAnnotations() כדי למצוא את ההערה ImAPlant. משתמשים בלחצן findAnnotation() כדי למצוא הערה ספציפית. מריצים את התוכנית ומעיינים בתוצאה.

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

⇒ @example.ImAPlant()

שלב 3: יצירת הערה ממוקדת

ההערות יכולות לטרגט getters או setters. אם כן, אפשר להשתמש בהם עם הקידומת @get: או @set:. הבעיה הזו נפוצה כשמשתמשים במסגרות עם הערות.

מצהירים על שתי הערות, OnGet שאפשר להחיל רק על getters של מאפיינים, ו-OnSet שאפשר להחיל רק על setters של מאפיינים. משתמשים ב-@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 יש לולאות עם מה שנקרא labeled break, שמאפשרות שליטה נוספת בלולאות. הפקודה 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. במקום לצאת מהלולאה עם התווית, הפקודה continue עם התווית ממשיכה לאיטרציה הבאה של הלולאה.

פונקציות למדה הן פונקציות אנונימיות, כלומר פונקציות ללא שם. אפשר להקצות אותם למשתנים ולהעביר אותם כארגומנטים לפונקציות ולשיטות. הם מאוד שימושיים.

שלב 1: יצירת פונקציית Lambda פשוטה

מפעילים את REPL ב-IntelliJ IDEA, ‏ Tools > Kotlin > Kotlin REPL.
תצור פונקציית למבדה עם ארגומנט, dirty: Int, שמבצעת חישוב, מחלקת את dirty ב-2. מקצים את ה-lambda למשתנה, waterFilter.

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

הפעלת הפונקציה waterFilter עם הערך 30.

waterFilter(30)

⇒ res0: kotlin.Int = 15

שלב 2: יצירת פונקציית Lambda של מסנן

עדיין ב-REPL, יוצרים מחלקת נתונים, Fish, עם מאפיין אחד, name.

data class Fish(val name: String)

תצור רשימה של 3 Fish, עם השמות פליפר, מובי דיק ודורי.

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() היא פונקציה, ומעבירים לה למדה שמציינת איך לעבד כל רכיב ברשימה.

כתיבת פונקציות מסדר גבוה עם ביטויי למדה להרחבה היא אחד החלקים המתקדמים ביותר בשפת Kotlin. לוקח זמן ללמוד איך לכתוב אותם, אבל הם מאוד נוחים לשימוש.

שלב 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() היא למעשה פונקציה מסדר גבוה, ובפונקציית ה-lambda מציינים מה לעשות עם האובייקט שסופק.

משתמשים ב-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() היא תוסף שפועל עם כל הסוגים. היא מקבלת lambda אחד כארגומנט ומחזירה את התוצאה של הפעלת ה-lambda.

ב-fishExamples(), מתקשרים אל run() ב-fish כדי לקבל את השם.

fish.run {
   name
}

הפונקציה הזו מחזירה רק את הנכס name. אפשר להקצות את הערך הזה למשתנה או להדפיס אותו. זו לא דוגמה שימושית במיוחד, כי אפשר פשוט לגשת לנכס, אבל run() יכול להיות שימושי לביטויים מורכבים יותר.

הפונקציה apply() דומה לפונקציה run(), אבל היא מחזירה את האובייקט שחל עליו השינוי במקום את התוצאה של ה-lambda. האפשרות הזו יכולה להיות שימושית כשרוצים להפעיל שיטות באובייקט שנוצר לאחרונה.

יוצרים עותק של 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.

אם תדפיסו את fish אחרי הקריאה ל-let(), תראו שהיא לא השתנתה.

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 יש method, ‏ 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 אומר שבכל פעם שהפונקציה נקראת, המהדר למעשה ישנה את קוד המקור כדי להוסיף את הפונקציה 'בתוך השורה'. כלומר, הקומפיילר ישנה את הקוד כדי להחליף את הביטוי למבדה בהוראות שבתוך הביטוי למבדה.

אם myWith() בדוגמה שלמעלה מסומן ב-inline:

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

היא הופכת לשיחה ישירה:

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

חשוב לציין ששימוש ב-inlining בפונקציות גדולות מגדיל את גודל הקוד, ולכן מומלץ להשתמש בו בפונקציות פשוטות שמשמשות פעמים רבות, כמו myWith(). הפונקציות של התוסף מהספריות שהוזכרו קודם מסומנות ב-inline, כך שלא צריך לדאוג לגבי יצירה של אובייקטים נוספים.

Single Abstract Method (שיטה מופשטת יחידה) פשוט מציינת ממשק עם שיטה אחת. הם נפוצים מאוד כשמשתמשים בממשקי API שנכתבו בשפת התכנות Java, ולכן יש ראשי תיבות לציון שלהם, SAM. לדוגמה, Runnable, שיש לו שיטה מופשטת אחת, run(), ו-Callable, שיש לו שיטה מופשטת אחת, call().

ב-Kotlin, צריך להפעיל כל הזמן פונקציות שמקבלות SAM כפרמטרים. אפשר לנסות את הדוגמה הבאה.

בתוך example, יוצרים מחלקה ב-Java‏, 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. כמובן, ב-Kotlin יש דרך פשוטה יותר לעשות את זה – אפשר להשתמש בביטוי למדה במקום באובייקט כדי שהקוד יהיה הרבה יותר קומפקטי.

מסירים את הקוד הקיים ב-runExample, משנים אותו לקריאה ל-runNow() באמצעות lambda ומריצים את התוכנית.

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, ‏ Single Abstract Method (שיטה מופשטת יחידה). אפשר ליצור מופע של SAM, לבטל את ההגדרה שלו ולבצע קריאה אליו באמצעות שורה אחת של קוד, לפי התבנית:
Class.singleAbstractMethod { lambda_of_override }

בשיעור הזה סקרנו את פונקציות ה-lambda והעמקנו בפונקציות מסדר גבוה – חלקים חשובים ב-Kotlin. למדתם גם על הערות ועל הפסקות עם תוויות.

אפשר להשתמש בהערות כדי לציין דברים לקומפיילר. לדוגמה:
@file:JvmName("Foo")
אפשר להשתמש בהפסקות עם תוויות כדי לאפשר לקוד לצאת מתוך לולאות מקוננות. לדוגמה:
if (i > 10) break@outerLoop // breaks to outerLoop label
פונקציות למבדה יכולות להיות יעילות מאוד בשילוב עם פונקציות מסדר גבוה.
פונקציות למבדה הן אובייקטים. כדי להימנע מיצירת האובייקט, אפשר לסמן את הפונקציה באמצעות inline, והקומפיילר יציב את התוכן של ה-lambda בקוד ישירות.
חשוב להשתמש ב-inline בזהירות, אבל הוא יכול לעזור לצמצם את השימוש במשאבים של התוכנית.
‫SAM, ‏ Single Abstract Method (שיטה מופשטת יחידה), הוא דפוס נפוץ, והוא פשוט יותר עם ביטויי למדה. התבנית הבסיסית היא:
Class.singleAbstractMethod { lamba_of_override }
הספרייה הסטנדרטית של Kotlin מספקת פונקציות שימושיות רבות, כולל כמה פונקציות SAM, ולכן כדאי להכיר את התוכן שלה.

יש עוד הרבה דברים שאפשר ללמוד על Kotlin מעבר למה שמופיע בקורס, אבל עכשיו יש לכם את הידע הבסיסי שדרוש כדי להתחיל לפתח תוכניות משלכם ב-Kotlin. אנחנו מקווים שאתם מתלהבים מהשפה הזו, ומצפים ליצור עוד פונקציות תוך כתיבת פחות קוד (במיוחד אם אתם מגיעים משפת התכנות Java). הדרך הכי טובה להפוך למומחים ב-Kotlin היא להתאמן וללמוד תוך כדי עבודה, לכן מומלץ להמשיך לחקור וללמוד על Kotlin באופן עצמאי.

תיעוד של Kotlin

אם אתם רוצים לקבל מידע נוסף על נושא כלשהו בקורס הזה, או אם נתקעתם, https://kotlinlang.org הוא המקום הכי טוב להתחיל בו.

מדריכים ל-Kotlin

באתר https://try.kotlinlang.org יש הדרכות מפורטות שנקראות Kotlin Koans, מפרש מבוסס-אינטרנט וסט מלא של מסמכי עזר עם דוגמאות.

קורס של Udacity

כדי לצפות בקורס של Udacity בנושא הזה, אפשר לעבור אל Kotlin Bootcamp for Programmers.

IntelliJ IDEA

מסמכי התיעוד של IntelliJ IDEA זמינים באתר JetBrains.

Kotlin Standard Library

ספריית התקנים של Kotlin מספקת פונקציות שימושיות רבות. לפני שכותבים פונקציה או ממשק משלכם, תמיד כדאי לבדוק בספרייה הרגילה אם מישהו כבר עשה את העבודה הזו. כדאי לחזור לכאן מדי פעם, כי אנחנו מוסיפים פונקציות חדשות לעיתים קרובות.

מדריכים ל-Kotlin

באתר https://try.kotlinlang.org יש הדרכות מפורטות שנקראות Kotlin Koans, מפרש מבוסס-אינטרנט וסט מלא של מסמכי עזר עם דוגמאות.

קורס של Udacity

כדי לצפות בקורס של Udacity בנושא הזה, אפשר לעבור אל Kotlin Bootcamp for Programmers.

IntelliJ IDEA

מסמכי התיעוד של IntelliJ IDEA זמינים באתר JetBrains.

בקטע הזה מפורטות אפשרויות למשימות ביתיות לתלמידים שעובדים על ה-Codelab הזה כחלק מקורס בהנחיית מדריך. המורה צריך:

אם צריך, מקצים שיעורי בית.
להסביר לתלמידים איך להגיש מטלות.
בודקים את שיעורי הבית.

אנשי ההוראה יכולים להשתמש בהצעות האלה כמה שרוצים, ומומלץ להם להקצות כל שיעורי בית אחרים שהם חושבים שמתאימים.

אם אתם עובדים על ה-codelab הזה לבד, אתם יכולים להשתמש במשימות האלה כדי לבדוק את הידע שלכם.

עונים על השאלות הבאות

שאלה 1

ב-Kotlin, ‏ SAM מייצג:

▢ התאמה בטוחה של ארגומנטים

‫▢ שיטת גישה פשוטה

‫▢ Single Abstract Method (שיטה מופשטת יחידה)

▢ מתודולוגיית גישה אסטרטגית

שאלה 2

איזו מהאפשרויות הבאות היא לא פונקציית הרחבה של ספריית Kotlin Standard?

▢ elvis()

▢ apply()

▢ run()

▢ with()

שאלה 3

איזו מהאפשרויות הבאות לא נכונה לגבי ביטויי למדה ב-Kotlin?

‫▢ פונקציות למדה הן פונקציות אנונימיות.

‫▢ Lambdas הם אובייקטים, אלא אם הם מוטמעים.

‫▢ פונקציות Lambda צורכות הרבה משאבים ולכן לא מומלץ להשתמש בהן.

‫▢ אפשר להעביר פונקציות למבדה לפונקציות אחרות.

שאלה 4

תוויות ב-Kotlin מסומנות במזהה שאחריו מופיע:

▢ :

▢ ::

▢ @:

▢ @

מעולה! סיימת את ה-codelab בנושא Kotlin Bootcamp for Programmers.

סקירה כללית של הקורס, כולל קישורים ל-Codelabs אחרים, זמינה במאמר "Kotlin Bootcamp for Programmers: Welcome to the course".

Kotlin Bootcamp for Programmers 6: Functional manipulation קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

מבוא

מה שכדאי לדעת

מה תלמדו

הפעולות שתבצעו:

שלב 1: יוצרים חבילה וקובץ חדשים

שלב 2: יצירת הערה

שלב 3: יצירת הערה ממוקדת

שלב 1: יצירת פונקציית Lambda פשוטה

שלב 2: יצירת פונקציית Lambda של מסנן

שלב 1: יוצרים כיתה חדשה

שלב 2: שימוש בפונקציה מסדר גבוה

שלב 3: יצירת פונקציה מסדר גבוה

שלב 4: מידע נוסף על תוספים מובנים

תיעוד של Kotlin

מדריכים ל-Kotlin

קורס של Udacity

IntelliJ IDEA

Kotlin Standard Library

מדריכים ל-Kotlin

קורס של Udacity

IntelliJ IDEA

עונים על השאלות הבאות

שאלה 1

שאלה 2

שאלה 3

שאלה 4

Kotlin Bootcamp for Programmers 6: Functional manipulation