משפטי תנאי ב-Kotlin – חלק 1

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

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

דרישות מוקדמות

• איך פותחים, עורכים ומריצים קוד בכתובת https://try.kotlinlang.org/
• יכולת ליצור ולהריץ תוכנית Kotlin שמשתמשת במשתנים, בפונקציות עם ארגומנטים, במחלקות עם שיטות ומדפיסה תוצאה במסוף.

מה תלמדו

• איך משתמשים בהצהרות if ו-else
• איך משווים ערכים באמצעות אופרטורים כמו גדול מ- (>), קטן מ- (<) ושווה ל- (==).
• איך משתמשים בהצהרות when כדי לבחור אפשרות על סמך ערך נתון.
• מהו סוג הנתונים Boolean ואיך להשתמש בערכים true ו-false שלו כדי לקבל החלטות.

מה תפַתחו

• משחק קוביות מבוסס-Kotlin, ‏ Lucky Dice Roll, שמאפשר לציין מספר מזל. שחקן ינצח אם הוא יטיל את המספר המזל.

מה צריך

• מחשב עם חיבור לאינטרנט.

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

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

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

בתוכנית Lucky Dice Roller, האפליקציה צריכה לטפל במקרים שונים, כמו:

• אם התוצאה של הטלת הקובייה היא המספר המזל, מוצגת הודעת ברכה.
• Else if the dice roll is not the lucky number, then display a message to try again.

כדי להוסיף את הלוגיקה הזו לקוד, צריך להשתמש במילות מפתח מיוחדות של Kotlin כמו if,‏ else ו-when.

ריכזנו כאן כמה דוגמאות.

משתמשים בהצהרת if כדי להגדיר תנאי שמתקיים

1. בודקים את הקוד שלמטה. מה לדעתך יהיה הפלט?

fun main() {
   val num = 5
   if (num > 4) {
       println("The variable is greater than 4")
   }
}

2. מעתיקים את הקוד ומדביקים אותו בכלי לעריכת תוכניות ב-Kotlin, ומריצים את התוכנית כדי לראות את הפלט.

The variable is greater than 4

תהליך קבלת ההחלטות בתוכנית הזו הוא:

1. יוצרים משתנה num ומגדירים אותו לערך 5.
2. אם נכון ש-num גדול מ-4,, המערכת תדפיס "The variable is greater than 4".>
3. בכל מצב אחר, לא צריך לעשות כלום.

בדוגמה שלמעלה, הערך של num הוא 5. ההצהרה if משווה אם המשתנה גדול מ-4. מכיוון שהתנאי מתקיים, המערכת מבצעת את ההוראות שבסוגריים המסולסלים ומדפיסה את ההודעה.

סיכום: הסמל > הוא אופרטור להשוואה בין שני ערכים, כדי לבדוק אם הערך הראשון גדול מהערך השני, והוא מחזיר את התוצאה true או false. אופרטורים נפוצים אחרים: < (קטן מ-), == (שווה ל-), >= (גדול מ- או שווה ל-) ו-<= (קטן מ- או שווה ל-).

שימו לב לפורמט הכללי של הצהרת if:

• מתחילים עם מילת המפתח if.
• מוסיפים שני זוגות של סוגריים (). בתוך הסוגריים מזינים את התנאי. התנאי יכול להיות כל דבר ששווה ל-true או ל-false. לדוגמה, אם מספר מסוים גדול ממספר אחר.
• מוסיפים שתי סוגריים מסולסלים {}. בתוך הסוגריים המסולסלים מזינים את הקוד שיפעל אם התנאי הוא true.

if (condition-is-true) {
    execute-this-code
}

סוג נתונים בוליאני לערכים true ו-false:

• התהליך שבו בודקים אם תנאי מסוים מתקיים נקרא 'הערכת התנאי'. התוצאה של הערכת תנאי היא true אם התנאי מתקיים, או false אם הוא לא מתקיים. המפתחים גם מציינים אם התנאי שווה ל-true או ל-false.
• התנאים יכולים לקבל רק את הערכים true או false.
• בדומה לסוג הנתונים Int למספרים שלמים ולסוג הנתונים IntRange לטווחים, יש סוג נתונים ל-true ול-false שנקרא Boolean. בהמשך הקורס הזה תיתקלו במשתנים מסוג Boolean.

משתמשים בהצהרת if כדי להגדיר תנאי שלא מתקיים

1. משנים את הערך של num ל-3, כמו שמוצג למטה. מה לדעתך יקרה אם תפעיל את הקוד הזה?

fun main() {
   val num = 3
   if (num > 4) {
       println("The variable is greater than 4")
   }
}

2. מעתיקים את הקוד ומדביקים אותו בכלי לעריכת תוכניות ב-Kotlin, ומריצים את התוכנית כדי לראות את הפלט.

אם הערך של num הוא 3, לא יודפס כלום כי הוא קטן מ-4.num לכן התנאי num גדול מ-4 הוא false, הקוד בין הסוגריים המסולסלים לא מופעל ולא מודפס כלום.

שימוש ב-else כדי ליצור חלופה לתנאים שנכשלו

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

1. מוסיפים הצהרת else כדי להדפיס הודעה אם num לא גדול מ-4, כמו שמוצג בהמשך. מה לדעתך יקרה אם תפעיל את הקוד הזה?

fun main() {
   val num = 3
   if (num > 4) {
       println("The variable is greater than 4")
   } else {
       println("The variable is less than 4")
   }
}

2. מעתיקים את הקוד ומדביקים אותו בכלי לעריכת תוכניות ב-Kotlin, ומריצים את התוכנית כדי לראות את הפלט.

The variable is less than 4

3. שימו לב: כשהערך של num הוא 3, התוכנית מדפיסה את ההודעה "The variable is less than 4" שמשויכת להצהרה else כי num לא גדול מ-4 .
4. משנים את הערך של num ל-5 ומריצים את התוכנית שוב. עכשיו, הערך של num גדול מ-4, והתוכנית מדפיסה את הערך The variable is greater than 4.
5. משנים את num ל-4 ומריצים את התוכנית. עכשיו 4 לא גדול מ-4, והתוכנית מדפיסה 'The variable is less than 4'.

הפלט הנכון לתנאים שהגדרתם בקוד הוא 'The variable is less than 4', אבל ההצהרה המודפסת לא מדויקת, כי 4 הוא לא פחות מ-4. אפשר להוסיף עוד תנאי שיבדוק את האפשרות השלישית, אם num הוא בדיוק 4, וידפיס הצהרה נכונה כשהתנאי הזה מתקיים.

שימוש בשילוב else + if כדי להוסיף תנאים חלופיים

אפשר להוסיף יותר מתנאי אחד. בדוגמה שלכם, כך אפשר לכסות את כל האפשרויות של num:

• אם num גדול מ-4, מדפיסים את The variable is greater than 4.
• Else if num is equal to 4, print "The variable is equal to 4".
• אחרת, מדפיסים את "The variable is less than 4".

הם נקראים מקרים שונים בהצהרת if-else. מוצגות 3 בקשות תמיכה.

הקוד המעודכן נראה כך:

fun main() {
   val num = 4
   if (num > 4) {
       println("The variable is greater than 4")
   } else if (num == 4) {
       println("The variable is equal to 4")
   } else {
       println("The variable is less than 4")
   }
}

שימו לב לשינויים הבאים:

• הערך של num מוגדר עכשיו ל-4, כדי שתוכלו לבדוק את התנאי החדש.
• בין ההצהרות המקוריות if ו-else יש הצהרה חדשה else if למקרה שבו num הוא בדיוק 4.

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

The variable is equal to 4

2. נסו לשנות את הערך של num ולראות איך זה משפיע על הפלט. משנים את num ל-2 ול-6, כדי לראות את כל התנאים true.

בקרת זרימה

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

• נניח שהטלת הקובייה num היא 3. התוכנית בודקת את התנאי הראשון (num > 4). התנאי הזה הוא false, ולכן התוכנית בודקת את התנאי הבא (num == 4), שהוא גם false. לאחר מכן התוכנית מריצה את הקוד של משפט ה-else, שהוא האפשרות האחרונה.
• אם התוצאה של הטלת הקובייה היא 6, התנאי הראשון (num > 4) מתקיים. התוכנית מדפיסה את ההודעה "The variable is greater than 4". מכיוון שהתנאי הזה מתקיים, אין צורך לבדוק את שאר התנאים, והפעולה מסתיימת עם הצהרת if-else.
• אפשר להשתמש בשילוב של else + if כדי להוסיף תנאים חלופיים.

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

הגדרת קוד התחלתי

אתם מתחילים את התוכנה Lucky Dice Roller עם קוד שדומה לקוד הפתרון של התוכנה הקודמת Kotlin Dice Roller. אפשר לערוך את הפונקציה main() בקוד הקודם כך שתתאים, או להעתיק ולהדביק את הקוד שלמטה כדי להתחיל.

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        return (1..numSides).random()
    }
}

בודקים אם המספר המזל הוגרל

קודם יוצרים מספר מזל, ואז משווים את תוצאת הטלת הקובייה למספר הזה.

.

1. ב-main(), מוחקים את ההצהרה println().
2. ב-main(), מוסיפים val בשם luckyNumber ומגדירים את הערך שלו ל-4. הקוד אמור להיראות כך.

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4
}

3. מתחת לזה, מוסיפים הצהרת if עם תנאי בתוך הסוגריים () שבודק אם rollResult שווה (==) ל-luckyNumber. משאירים קצת מקום בין הסוגריים המסולסלים {} כדי שאפשר יהיה להוסיף עוד קוד.

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4
    if (rollResult == luckyNumber) {

    }
}

4. בתוך הסוגריים המסולסלים {}, מוסיפים הצהרה של println כדי להדפיס "You win!"

fun main() {
    val myFirstDice = Dice(6)
    val rollResult = myFirstDice.roll()
    val luckyNumber = 4

    if (rollResult == luckyNumber) {
        println("You win!")
    }
}

5. מפעילים את התוכנית. יכול להיות שתצטרכו להריץ אותו כמה פעמים עד שתצליחו לראות את ההודעה המנצחת בפלט.

You win!

תגובה כשלא יוצא המספר המזל

אם המשתמש לא זכה בתוכנית ולא קיבל משוב, הוא עלול לתהות אם התוכנית לא תקינה. מומלץ תמיד לספק תגובה כשהמשתמש מבצע פעולה כלשהי. בתוכנית Lucky Dice Roller, אפשר להשתמש בהצהרת else כדי להודיע למשתמשים שהם לא זכו.

1. מוסיפים הצהרה של else כדי להדפיס את "You didn't win, try again!".

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   if (rollResult == luckyNumber) {
       println("You win!")
   } else {
       println("You didn't win, try again!")
   }
}

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

בשלב הזה, המשתמשים יודעים אם הם זכו או לא, אבל לא למה. תמיד צריך לספק למשתמשים מידע כדי שהם יבינו את התוצאה של הפעולות שלהם. נניח שהתוכנית שלכם היא בקשה להלוואה. המשפט "לא אושרת כי דירוג האשראי שלך נמוך" מספק הרבה יותר מידע מהמשפט "מצטערים, לא נוכל לאשר לך הלוואה. נסה שוב!". במשחק Lucky Dice Roller, אפשר להציג למשתמשים הודעה אינפורמטיבית שונה לכל הטלה אם הם הפסידו. כדי לעשות את זה, משתמשים בכמה הצהרות else if.

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

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   if (rollResult == luckyNumber) {
       println("You win!")
   } else if (rollResult == 1) {
       println("So sorry! You rolled a 1. Try again!")
   } else if (rollResult == 2) {
       println("Sadly, you rolled a 2. Try again!")
   } else if (rollResult == 3) {
       println("Unfortunately, you rolled a 3. Try again!")
   } else if (rollResult == 4) {
       println("No luck! You rolled a 4. Try again!")
   } else if (rollResult == 5) {
       println("Don't cry! You rolled a 5. Try again!")
   } else {
       println("Apologies! you rolled a 6. Try again!")
   }
}

בדוגמה של הקוד שלמעלה,

• בודקים אם rollResult הוא luckyNumber.
• אם rollResult הוא luckyNumber, מדפיסים את ההודעה הזוכה.
• אחרת, בודקים אם הערך של rollResult הוא 1, ואם כן, מדפיסים הודעה שמבקשת לנסות שוב.
• אחרת, בודקים אם הערך של rollResult הוא 2, ואם כן, מדפיסים הודעה אחרת של ניסיון חוזר.
• אחרת, ממשיכים לבדוק עד המספר 5.
• אם המספר לא היה אף אחד מהמספרים 1 עד 5, האפשרות היחידה שנותרה היא 6, ולכן אין צורך בבדיקה נוספת עם else if, ואפשר פשוט לתפוס את האפשרות האחרונה הזו באמצעות ההצהרה הסופית else.

טיפ: אפשר להשתמש רק בהצהרה אחת של if ובהצהרה אחת של else בבלוק קוד של if-else, אבל ביניהן אפשר להשתמש בכמה הצהרות של else if שרוצים.

מכיוון ששימוש בכמה מקרים של else if הוא נפוץ מאוד, ב-Kotlin יש דרך פשוטה יותר לכתוב אותם.

בדיקה של הרבה תוצאות או מקרים שונים היא דבר נפוץ מאוד בתכנות. לפעמים, רשימת התוצאות האפשריות יכולה להיות ארוכה מאוד. לדוגמה, אם מטילים קובייה בעלת 12 צדדים, יהיו 11 משפטי else if בין ההצלחה לבין else הסופי. כדי להקל על כתיבה וקריאה של הצהרות כאלה, וכך למנוע שגיאות, Kotlin מספקת הצהרה של when.

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

1. בתוכנית, בקטע main(), בוחרים את הקוד מההצהרה הראשונה if עד לסוגר המסולסל } שסוגר את ההצהרה האחרונה else ומוחקים אותו.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4
}

2. ב-main(), מתחת להצהרה בנושא luckyNumber, יוצרים הצהרה בנושא when. מכיוון שצריך לבדוק את when מול התוצאה שהופעלה, צריך להזין את rollResult בין הסוגריים (). מוסיפים סוגריים מסולסלים {} עם רווחים נוספים, כמו בדוגמה שלמטה.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {

   }
}

כמו קודם, קודם בודקים אם rollResult זהה ל-luckyNumber.

1. בתוך הסוגריים המסולסלים {} של ההצהרה when, מוסיפים הצהרה שבודקת אם rollResult זהה ל-luckyNumber, ואם כן, מדפיסה את ההודעה המנצחת. ההצהרה נראית כך:

luckyNumber -> println("You win!")

כלומר:

• קודם מזינים את הערך שאליו משווים rollResult. זה אומר שנשארו luckyNumber.
• אחריו מוסיפים חץ (->).
• אחר כך מוסיפים את הפעולה שתתבצע אם יש התאמה.

המשמעות היא: "אם rollResult הוא luckyNumber, אז מדפיסים את ההודעה "You win!"".

הקוד של main() נראה כך.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You win!")
   }
}

2. משתמשים באותו דפוס כדי להוסיף שורות והודעות לתוצאות האפשריות 1 עד 6, כמו שמוצג למטה. הפונקציה main() המוגמרת אמורה להיראות כך.

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You won!")
       1 -> println("So sorry! You rolled a 1. Try again!")
       2 -> println("Sadly, you rolled a 2. Try again!")
       3 -> println("Unfortunately, you rolled a 3. Try again!")
       4 -> println("No luck! You rolled a 4. Try again!")
       5 -> println("Don't cry! You rolled a 5. Try again!")
       6 -> println("Apologies! you rolled a 6. Try again!")
   }
}

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

מעולה! למדתם שתי דרכים להדפסת הודעות בהתאם לתנאי מסוים. זהו כלי רב-עוצמה לכתיבת תוכניות מעניינות!

fun main() {
   val myFirstDice = Dice(6)
   val rollResult = myFirstDice.roll()
   val luckyNumber = 4

   when (rollResult) {
       luckyNumber -> println("You won!")
       1 -> println("So sorry! You rolled a 1. Try again!")
       2 -> println("Sadly, you rolled a 2. Try again!")
       3 -> println("Unfortunately, you rolled a 3. Try again!")
       4 -> println("No luck! You rolled a 4. Try again!")
       5 -> println("Don't cry! You rolled a 5. Try again!")
       6 -> println("Apologies! you rolled a 6. Try again!")
   }
}

class Dice(val numSides: Int) {
   fun roll(): Int {
       return (1..numSides).random()
   }
}

• משתמשים בהצהרת if כדי להגדיר תנאי להרצת חלק מההוראות. לדוגמה, אם המשתמש מגלגל את המספר המזל, מדפיסים הודעת זכייה.
• סוג הנתונים Boolean כולל את הערכים true ו-false, ואפשר להשתמש בו לקבלת החלטות.
• השוואת ערכים באמצעות אופרטורים כמו גדול מ- (>), קטן מ- (<) ושווה ל- (==).
• משתמשים בשרשרת של הצהרות else if כדי להגדיר כמה תנאים. לדוגמה, אפשר להדפיס הודעה שונה לכל תוצאה אפשרית של הטלת קובייה.
• משתמשים בהצהרת else בסוף שרשרת של תנאים כדי לטפל במקרים שלא נכללים באופן מפורש. אם תכסו את המקרים של קובייה בעלת 6 צדדים, הצהרת else תזהה את המספרים 7 ו-8 שהוגרלו בקובייה בעלת 8 צדדים.
• אפשר להשתמש בהצהרת when כדרך קומפקטית להריץ קוד על סמך השוואה של ערך.

הצורה הכללית של if-else:

if (condition-is-true) {

execute-this-code

} else if (condition-is-true) {

execute-this-code

} else {

execute-this-code

}

הצהרה על שימוש:

when (variable) {

matches-value -> execute-this-code

matches-value -> execute-this-code

...

}

• Kotlin: Control flow
• ‫Kotlin: when
• תנאים

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

מבצעים את הפעולות הבאות:

1. משנים את myFirstDice ל-8 צלעות ומריצים את הקוד. מה קורה

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

2. מתקנים את הצהרת when כך שתכלול את כל 8 הצדדים. כדי לעשות את זה, מוסיפים מקרים למספרים הנוספים. בעיה: במקום להוסיף מקרה חדש לכל מספר, כדאי להשתמש בהצהרת else כדי לטפל בכל המקרים שלא נכללים באופן מפורש.

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

3. משנים את myFirstDice כך שיהיו לו רק 4 צלעות. מה קורה

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