หน้านี้ได้รับการแปลโดย Cloud Translation API

คำสั่งแบบมีเงื่อนไขใน 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 ของคุณต้องพิจารณาว่าผู้ใช้ทอยได้หมายเลขนำโชคและได้รับข้อความแสดงความยินดี หรือได้รับข้อความให้ลองอีกครั้ง

ในฐานะนักพัฒนาแอป คุณจะต้องตัดสินใจเกี่ยวกับลักษณะการทำงานของแอปและสร้างผลลัพธ์ที่แตกต่างกันสำหรับผู้ใช้

หากคุณกำลังสร้างแอปช็อปปิ้ง คุณอาจแสดงหน้าจอที่แตกต่างกันตามตัวเลือกการนำส่งที่ผู้ใช้เลือก สำหรับเกมแบบทดสอบ คุณจะต้องแสดงหน้าจอที่แตกต่างกันตามคำตอบของผู้เล่นว่าถูกต้องหรือไม่ แอปอาจมีผลลัพธ์ที่เป็นไปได้หลายอย่าง ซึ่งคุณจะต้องพิจารณาในโค้ด

ในโปรแกรม Lucky Dice Roller แอปควรจัดการกรณีต่างๆ เช่น

หากลูกเต๋าออกหมายเลขนำโชค ให้แสดงข้อความแสดงความยินดี
มิฉะนั้น หากลูกเต๋าไม่ได้ทอยได้หมายเลขนำโชค ให้แสดงข้อความให้ลองอีกครั้ง

หากต้องการเพิ่มตรรกะนี้ลงในโค้ด ให้ใช้คีย์เวิร์ดพิเศษของ Kotlin เช่น if และ else รวมถึง when

มาดูตัวอย่างกัน

ใช้คำสั่ง `if` เพื่อตั้งค่าเงื่อนไขที่ตรงกัน

ตรวจสอบโค้ดด้านล่าง คุณคิดว่าเอาต์พุตจะเป็นอะไร

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

คัดลอกและวางโค้ดในโปรแกรมแก้ไขโปรแกรม Kotlin แล้วเรียกใช้โปรแกรมเพื่อดูเอาต์พุต

The variable is greater than 4

กระบวนการตัดสินใจสำหรับโปรแกรมนี้มีดังนี้

สร้างตัวแปร num และตั้งค่าเป็น 5.
If it is true that num is greater (>) than 4, print "The variable is greater than 4".
ในสถานการณ์อื่นๆ ทั้งหมด ให้ไม่ต้องดำเนินการใดๆ

ในตัวอย่างข้างต้น num จะตั้งค่าเป็น 5 คำสั่ง if จะเปรียบเทียบว่าตัวแปรมีค่ามากกว่า 4 หรือไม่ เนื่องจากเป็นจริง ระบบจึงดำเนินการตามคำสั่งในวงเล็บปีกกาและพิมพ์ข้อความ

โปรดสังเกตรูปแบบทั่วไปของคำสั่ง if

เริ่มต้นด้วยคีย์เวิร์ด if
ตามด้วยวงเล็บ 2 อัน () โดยใส่เงื่อนไขไว้ในวงเล็บ เงื่อนไขคือสิ่งใดก็ตามที่สามารถเป็น true หรือ false เช่น ตัวเลขหนึ่งมากกว่าอีกตัวเลขหนึ่งหรือไม่
ตามด้วยวงเล็บปีกกา 2 อัน {} ภายในวงเล็บปีกกา ให้ใส่โค้ดที่จะเรียกใช้หากเงื่อนไขเป็น true

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

ประเภทข้อมูลบูลีนสำหรับค่าจริงและค่าเท็จ:

การที่โปรแกรมจะทดสอบว่าตรงตามเงื่อนไขหรือไม่เรียกว่า "การประเมินเงื่อนไข" ผลลัพธ์ของการประเมินเงื่อนไขคือ true หากตรงตามเงื่อนไข หรือ false หากไม่ตรงตามเงื่อนไข นักพัฒนาแอปยังพูดว่า "เงื่อนไขประเมินค่าเป็น true" หรือ "เงื่อนไขประเมินค่าเป็น false"
เงื่อนไขจะประเมินได้เป็น true หรือ false เท่านั้น
เช่นเดียวกับที่มีประเภทข้อมูล Int สำหรับจำนวนเต็ม และ IntRange สำหรับช่วง ก็มีประเภทข้อมูลสำหรับ true และ false เช่นกัน ซึ่งเรียกว่า Boolean คุณจะพบตัวแปรประเภท Boolean ในหลักสูตรนี้ในภายหลัง

ใช้คำสั่ง `if` เพื่อตั้งค่าเงื่อนไขที่ไม่เป็นไปตามที่กำหนด

เปลี่ยนค่าของ num เป็น 3 ดังที่แสดงด้านล่าง คุณคิดว่าจะเกิดอะไรขึ้นหากเรียกใช้โค้ดนี้

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

คัดลอกและวางโค้ดในโปรแกรมแก้ไขโปรแกรม Kotlin แล้วเรียกใช้โปรแกรมเพื่อดูเอาต์พุต

เมื่อตั้งค่า num เป็น 3 จะไม่มีการพิมพ์ใดๆ เนื่องจากค่าของ num น้อยกว่า 4 ดังนั้นเงื่อนไขที่ว่า num ต้องมากกว่า 4 จึงเป็น false และโค้ดระหว่างเครื่องหมายปีกกาจะไม่ทำงาน และจะไม่มีการพิมพ์อะไรออกมา

ใช้ `else` เพื่อสร้างทางเลือกสำหรับเงื่อนไขที่ไม่สำเร็จ

คุณสามารถเสนอทางเลือกอื่นให้ผู้ใช้ได้เมื่อไม่เป็นไปตามเงื่อนไข แทนที่จะไม่ทำอะไรเลย คุณทำได้โดยใช้คำสั่ง else เช่นเดียวกับภาษาปกติ

เพิ่มคำสั่ง 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")
   }
}

คัดลอกและวางโค้ดในโปรแกรมแก้ไขโปรแกรม Kotlin แล้วเรียกใช้โปรแกรมเพื่อดูเอาต์พุต

The variable is less than 4

โปรดทราบว่าเมื่อ num มีค่าเป็น 3 โปรแกรมจะพิมพ์ข้อความ "The variable is less than 4" ที่เชื่อมโยงกับคำสั่ง else เนื่องจาก num ไม่มากกว่า 4
เปลี่ยน num เป็น 5 แล้วเรียกใช้โปรแกรมอีกครั้ง ตอนนี้ num มากกว่า 4 และโปรแกรมจะพิมพ์ "The variable is greater than 4"
เปลี่ยน num เป็น 4 แล้วเรียกใช้โปรแกรม ตอนนี้ 4 ไม่ได้มากกว่า 4 และโปรแกรมจะพิมพ์ "The variable is less than 4"

แม้ว่า "The variable is less than 4" จะเป็นเอาต์พุตที่ถูกต้องสำหรับเงื่อนไขที่คุณตั้งค่าไว้ในโค้ด แต่ข้อความที่พิมพ์นั้นไม่ถูกต้อง เนื่องจาก 4 ไม่น้อยกว่า 4 สิ่งที่คุณทำได้คือเพิ่มเงื่อนไขอื่นที่ตรวจสอบความเป็นไปได้ที่ 3 ซึ่งก็คือ num เท่ากับ 4 หรือไม่ และพิมพ์ข้อความที่ถูกต้องเมื่อเงื่อนไขนั้นเป็นจริง

ใช้การผสมผสาน `else` + `if` เพื่อเพิ่มเงื่อนไขอื่น

คุณมีเงื่อนไขได้มากกว่า 1 รายการ สำหรับตัวอย่างของคุณ คุณจะครอบคลุมความเป็นไปได้ทั้งหมดสำหรับ 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

คัดลอกและวางโค้ดด้านบนในโปรแกรมแก้ไขโปรแกรม Kotlin แล้วเรียกใช้โปรแกรมเพื่อดูเอาต์พุต

The variable is equal to 4

ทดลองเปลี่ยนค่าของ num และดูว่าค่าดังกล่าวส่งผลต่อเอาต์พุตอย่างไร เปลี่ยน num เป็น 2 และ 6 เพื่อให้คุณเห็นเงื่อนไขแต่ละรายการtrue

ควบคุมโฟลว์

เมื่อดูคำสั่ง if-else ด้านบน โค้ดจะดำเนินการหรือไหลตามที่เงื่อนไขควบคุม ดังนั้น วิธีที่คุณใช้คำสั่งเหล่านี้เพื่อควบคุมการทำงานจึงเรียกว่า "โฟลว์การควบคุม" ของโปรแกรม

สมมติว่าคุณทอยลูกเต๋าได้ num 3 โปรแกรมจะตรวจสอบเงื่อนไขแรก (num > 4) ซึ่งเป็นเท็จ ดังนั้นโปรแกรมจึงตรวจสอบเงื่อนไขถัดไป (num == 4) ซึ่งเป็นเท็จเช่นกัน จากนั้นโปรแกรมจะเรียกใช้โค้ดของคำสั่ง else ซึ่งเป็นตัวเลือกสุดท้าย
หากการทอยลูกเต๋าได้ 6 เงื่อนไขแรก (num > 4) จะเป็นจริง โปรแกรมจะพิมพ์ข้อความ "The variable is greater than 4" เนื่องจากเงื่อนไขนี้เป็นจริง จึงไม่จำเป็นต้องตรวจสอบส่วนที่เหลือ และดำเนินการด้วยคำสั่ง if-else
ใช้การผสมผสาน else + if เพื่อเพิ่มเงื่อนไขทางเลือก

ในส่วนนี้ คุณจะใช้สิ่งที่ได้เรียนรู้ในงานก่อนหน้าเพื่ออัปเดตโปรแกรม Dice Roller เพื่อตรวจสอบว่าคุณทอยลูกเต๋าได้หมายเลขนำโชคที่ตั้งไว้ล่วงหน้าหรือไม่ หากคุณมี คุณก็ชนะ!

ตั้งค่าโค้ดเริ่มต้น

คุณกำลังเริ่มต้นใช้โปรแกรมลูกเต๋าเสี่ยงโชคด้วยโค้ดที่คล้ายกับโค้ดโซลูชันของโปรแกรมลูกเต๋าเสี่ยงโชค Kotlin ก่อนหน้า คุณสามารถแก้ไขฟังก์ชัน 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()
    }
}

ตรวจสอบว่ามีการทอยหมายเลขนำโชคแล้วหรือยัง

สร้างหมายเลขนำโชคก่อน แล้วเปรียบเทียบผลการทอยลูกเต๋ากับหมายเลขนั้น

ใน main() ให้ลบคำสั่ง println()
ใน main() ให้เพิ่ม val ที่ชื่อ luckyNumber และตั้งค่าเป็น 4 โค้ดควรมีลักษณะดังนี้

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

ที่ด้านล่าง ให้เพิ่มifคำสั่งที่มีเงื่อนไขภายในวงเล็บ () ซึ่งจะตรวจสอบว่า rollResult เท่ากับ (==) luckyNumber หรือไม่ เว้นที่ว่างระหว่างวงเล็บปีกกา {} เพื่อให้เพิ่มโค้ดได้

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

    }
}

ภายในวงเล็บปีกกา {} ให้เพิ่มคำสั่ง println เพื่อพิมพ์ "You win!"

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

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

เรียกใช้โปรแกรม คุณอาจต้องเรียกใช้หลายครั้งก่อนที่จะโชคดีและเห็นข้อความที่ชนะในเอาต์พุต

You win!

ตอบเมื่อยังไม่ได้ทอยหมายเลขนำโชค

การไม่ได้รับความคิดเห็นจากโปรแกรมหากผู้ใช้ไม่ได้รับรางวัลอาจทำให้ผู้ใช้สงสัยว่าโปรแกรมมีปัญหาหรือไม่ แนวทางปฏิบัติที่ดีคือการตอบสนองเสมอเมื่อผู้ใช้ดำเนินการบางอย่าง สำหรับโปรแกรม Lucky Dice Roller คุณสามารถแจ้งให้ผู้ใช้ทราบว่าตนไม่ได้รับรางวัลโดยใช้else

เพิ่ม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!")
   }
}

เรียกใช้โปรแกรม และไม่ว่าผลลัพธ์จะเป็นอย่างไร ระบบจะแจ้งเตือนผู้ใช้เสมอ

ในขั้นตอนนี้ ผู้ใช้จะทราบว่าตนเองชนะหรือไม่ แต่ไม่ทราบสาเหตุ ให้ข้อมูลแก่ผู้ใช้เสมอเพื่อให้ผู้ใช้เข้าใจผลลัพธ์ของการกระทำของตน ลองนึกภาพว่าโปรแกรมของคุณคือใบสมัครขอสินเชื่อ "คุณไม่ได้รับอนุมัติเนื่องจากเครดิตไม่ดี" ให้ข้อมูลมากกว่า "ขออภัย คุณไม่ได้รับเงินกู้ โปรดลองอีกครั้ง" สำหรับเกมลูกเต๋าเสี่ยงโชค คุณสามารถแสดงข้อความที่ให้ข้อมูลที่แตกต่างกันแก่ผู้ใช้สำหรับการทอยแต่ละครั้งหากผู้ใช้แพ้ ใช้คำสั่ง else if หลายรายการเพื่อให้บรรลุเป้าหมายนี้

เพิ่มคำสั่ง 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 สุดท้ายได้

เนื่องจากelse ifเคสหลายรายการเป็นเรื่องปกติมาก Kotlin จึงมีวิธีเขียนที่ง่ายกว่า

การทดสอบผลลัพธ์หรือกรณีต่างๆ มากมายเป็นเรื่องปกติมากในการเขียนโปรแกรม บางครั้งรายการผลลัพธ์ที่เป็นไปได้อาจยาวมาก ตัวอย่างเช่น หากคุณทอยลูกเต๋า 12 ด้าน คุณจะมีข้อความ 11 ข้อความelse ifระหว่างข้อความแสดงความสำเร็จและข้อความสุดท้ายelse Kotlin มีคำสั่ง when เพื่อให้เขียนและอ่านคำสั่งประเภทนี้ได้ง่ายขึ้น ซึ่งจะช่วยหลีกเลี่ยงข้อผิดพลาด

คุณจะเปลี่ยนโปรแกรมให้ใช้คำสั่ง when when คำสั่งจะขึ้นต้นด้วยคีย์เวิร์ด when ตามด้วยวงเล็บ () ในวงเล็บคือค่าที่จะทดสอบ ตามด้วยเครื่องหมายปีกกา {} สำหรับโค้ดที่จะดำเนินการในเงื่อนไขต่างๆ

ในโปรแกรมของคุณ ใน main() ให้เลือกโค้ดจากคำสั่ง if แรกไปจนถึงวงเล็บปีกกา } ที่ปิดคำสั่ง else สุดท้าย แล้วลบออก

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

ใน main() ให้สร้างคำสั่ง when ใต้การประกาศของ luckyNumber เนื่องจาก when ต้องทดสอบกับผลลัพธ์ที่เปิดตัว ให้ใส่ rollResult ไว้ระหว่างวงเล็บ () เพิ่มเครื่องหมายปีกกา {} พร้อมเว้นวรรคเพิ่มเติมตามที่แสดงด้านล่าง

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

   when (rollResult) {

   }
}

เช่นเดียวกับก่อนหน้านี้ ให้ทดสอบก่อนว่า rollResult เหมือนกับ luckyNumber หรือไม่

ภายในวงเล็บปีกกา {} ของคำสั่ง 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!")
   }
}

ใช้รูปแบบเดียวกันเพื่อเพิ่มบรรทัดและข้อความสำหรับผลลัพธ์ที่เป็นไปได้ 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!")
   }
}

เรียกใช้โปรแกรม เอาต์พุตจะไม่มีความแตกต่าง แต่โค้ดจะกระชับและอ่านง่ายขึ้นมาก

ยินดีด้วย คุณได้เรียนรู้วิธีการพิมพ์ข้อความ 2 วิธีโดยขึ้นอยู่กับเงื่อนไข ซึ่งเป็นเครื่องมือที่มีประสิทธิภาพในการเขียนโปรแกรมที่น่าสนใจ

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 เป็นรูปแบบกะทัดรัดของการเรียกใช้โค้ดตามการเปรียบเทียบค่า

ทำดังนี้

เปลี่ยน myFirstDice ให้มี 8 ด้านแล้วเรียกใช้โค้ด สิ่งที่เกิดขึ้น

เคล็ดลับ: เมื่อเพิ่มจำนวนด้าน when ข้อความจะไม่ครอบคลุมทุกกรณีอีกต่อไป ดังนั้นสำหรับกรณีที่ไม่ครอบคลุม ระบบจะไม่พิมพ์อะไรเลย

แก้ไขข้อความ when เพื่อให้ครอบคลุมทั้ง 8 ด้าน คุณทำได้โดยเพิ่มเคสสำหรับหมายเลขเพิ่มเติม ความท้าทาย: แทนที่จะเพิ่มเคสใหม่สำหรับแต่ละหมายเลข ให้ใช้คำสั่ง else เพื่อจับเคสทั้งหมดที่ไม่ได้ครอบคลุมอย่างชัดเจน

เคล็ดลับ: คุณเพิ่มเคสเพื่อครอบคลุมด้านอื่นๆ ได้ ซึ่งเป็นวิธีที่ดีหากคุณต้องการข้อความที่แตกต่างกันสำหรับแต่ละหมายเลขที่สามารถหมุนได้ หรือคุณจะใช้elseและพิมพ์ข้อความเดียวกันสำหรับทุกด้านที่ใหญ่กว่า 6 ซึ่งครอบคลุมโดยรหัสปัจจุบันก็ได้

เปลี่ยน myFirstDice ให้มี 4 ด้านเท่านั้น สิ่งที่เกิดขึ้น

เคล็ดลับ: การเปลี่ยนจำนวนด้านของลูกเต๋าให้น้อยกว่าที่ระบุไว้ในคำสั่ง when จะไม่มีผลที่สังเกตได้ เนื่องจากกรณีทั้งหมดที่อาจเกิดขึ้นจะครอบคลุมอยู่แล้ว