Kotlin में कंडीशनल—पहला भाग

इस Kotlin कोडलैब में, आपको एक और डाइस गेम बनाना है. इसका नाम है, लकी डाइस रोल. इसमें आपको एक लकी नंबर लाने की कोशिश करनी है. आपका प्रोग्राम, एक लकी नंबर सेट करेगा और डाइस को रोल करेगा. इसके बाद, लकी नंबर के हिसाब से रोल की जांच की जाती है और आउटपुट में सही मैसेज प्रिंट किया जाता है. इसके लिए, आपको Kotlin प्रोग्राम में वैल्यू की तुलना करने और अलग-अलग फ़ैसले लेने का तरीका सीखना होगा.

आपको ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) के बारे में चिंता करने की ज़रूरत नहीं होगी, ताकि आप प्रोग्रामिंग के कॉन्सेप्ट पर ध्यान दे सकें. इसके लिए, आपको ब्राउज़र पर आधारित Kotlin प्रोग्रामिंग टूल का इस्तेमाल करना होगा. साथ ही, अपने नतीजों को कंसोल पर आउटपुट करना होगा.

ज़रूरी शर्तें

• https://try.kotlinlang.org/ में कोड खोलने, उसमें बदलाव करने, और उसे चलाने का तरीका
• वैरिएबल, आर्ग्युमेंट वाले फ़ंक्शन, और तरीकों वाली क्लास का इस्तेमाल करके, Kotlin प्रोग्राम बनाने और उसे चलाने की क्षमता. साथ ही, कंसोल पर नतीजे प्रिंट करने की क्षमता.

आपको क्या सीखने को मिलेगा

• if और else स्टेटमेंट इस्तेमाल करने का तरीका
• इससे ज़्यादा (>), इससे कम (<), और इसके बराबर (==) जैसे ऑपरेटर का इस्तेमाल करके वैल्यू की तुलना करने का तरीका.
• दी गई वैल्यू के आधार पर कोई विकल्प चुनने के लिए, when स्टेटमेंट का इस्तेमाल कैसे करें.
• Boolean डेटा टाइप क्या है और फ़ैसले लेने के लिए, इसकी true और false वैल्यू का इस्तेमाल कैसे करें.

आपको क्या बनाना है

• Kotlin पर आधारित डाइस गेम, Lucky Dice Roll. इसमें आपको एक लकी नंबर चुनने का विकल्प मिलता है. अगर कोई खिलाड़ी लकी नंबर लाता है, तो उसे विजेता माना जाएगा.

आपको इन चीज़ों की ज़रूरत पड़ेगी

• इंटरनेट कनेक्शन वाला कंप्यूटर.

आपके Lucky Dice Roller प्रोग्राम को यह तय करना है कि उपयोगकर्ता को लकी नंबर मिला है और उसे बधाई दी गई है या उसे फिर से कोशिश करने का मैसेज मिला है.

ऐप्लिकेशन डेवलपर के तौर पर, आपको यह तय करना होगा कि ऐप्लिकेशन को कैसे काम करना चाहिए और उपयोगकर्ताओं के लिए अलग-अलग नतीजे कैसे जनरेट करने चाहिए.

अगर आपको शॉपिंग ऐप्लिकेशन बनाना है, तो उपयोगकर्ता के चुने गए डिलीवरी के विकल्पों के आधार पर अलग-अलग स्क्रीन दिखाई जा सकती हैं. क्विज़ गेम के लिए, खिलाड़ी के जवाब के सही या गलत होने के आधार पर अलग-अलग स्क्रीन दिखाई जाती हैं. ऐप्लिकेशन के हिसाब से, कई तरह के नतीजे मिल सकते हैं. आपको अपने कोड में इन सभी नतीजों को शामिल करना होगा.

आपके Lucky Dice Roller प्रोग्राम में, ऐप्लिकेशन को इन अलग-अलग मामलों को हैंडल करना चाहिए:

• अगर डाइस रोल का नंबर लकी नंबर है, तो बधाई का मैसेज दिखाओ!
• Else if अगर डाइस रोल लकी नंबर नहीं है, तो फिर से कोशिश करने का मैसेज दिखाएं.

इस लॉजिक को अपने कोड में जोड़ने के लिए, 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 कीवर्ड से शुरू करें.
• इसके बाद, दो पैरंटheses () लगाएं. कोष्ठक के अंदर शर्त डाली जाती है. कंडिशन ऐसी होनी चाहिए जिसे true या false किया जा सके. उदाहरण के लिए, यह पता लगाना कि कोई संख्या किसी दूसरी संख्या से बड़ी है या नहीं.
• इसके बाद, दो कर्ली ब्रेसिज़ {} लगाएं. कर्ली ब्रैकेट के अंदर, वह कोड डाला जाता है जिसे कंडीशन true होने पर लागू करना है.

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

सही और गलत वैल्यू के लिए बूलियन डेटा टाइप:

• किसी प्रोग्राम के लिए, यह जांच करना कि कोई शर्त पूरी हुई है या नहीं, "शर्त का आकलन करना" कहलाता है. किसी शर्त के पूरा होने पर, नतीजे के तौर पर 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 पर सेट करने पर, कुछ भी प्रिंट नहीं होता, क्योंकि num की वैल्यू 4 से कम है. इसलिए, 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 होती है, तो प्रोग्राम else स्टेटमेंट से जुड़ा मैसेज "The variable is less than 4" प्रिंट करता है. ऐसा इसलिए होता है, क्योंकि 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".
• Else, print "The variable is less than 4".

इन्हें if-else स्टेटमेंट में अलग-अलग केस कहा जाता है. यहां तीन केस दिए गए हैं.

अपडेट किया गया कोड ऐसा दिखता है:

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) की जांच करता है. यह गलत है. इसलिए, प्रोग्राम अगली शर्त (num == 4) की जांच करता है. यह भी गलत है. इसके बाद, प्रोग्राम else स्टेटमेंट के कोड को लागू करता है, जो आखिरी विकल्प होता है.
• अगर डाइस रोल की संख्या 6 है, तो पहली शर्त (num > 4) सही है. प्रोग्राम, "The variable is greater than 4" मैसेज प्रिंट करता है. यह शर्त पूरी होने पर, बाकी शर्तों की जांच नहीं की जाती है. ऐसा if-else स्टेटमेंट की वजह से होता है.
• वैकल्पिक शर्तें जोड़ने के लिए, else + if कॉम्बिनेशन का इस्तेमाल करें.

इस सेक्शन में, पिछले टास्क में सीखी गई बातों का इस्तेमाल करके, डाइस रोलर प्रोग्राम को अपडेट किया जाएगा. इससे यह पता चलेगा कि आपने पहले से सेट किया गया लकी नंबर रोल किया है या नहीं. अगर आपके पास है, तो आपको इनाम मिलेगा!

स्टार्टर कोड सेट अप करना

आपने 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() में, luckyNumber नाम का val जोड़ें और इसे 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. कर्ली ब्रैकेट {} के अंदर, "You win!" को प्रिंट करने के लिए println स्टेटमेंट जोड़ें

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. प्रोग्राम को चलाएं. चाहे नतीजा कुछ भी हो, आपके उपयोगकर्ताओं को हमेशा इसकी सूचना दी जाती है.

इस समय, उपयोगकर्ताओं को पता चल जाता है कि वे जीते हैं या नहीं. हालांकि, उन्हें इसकी वजह नहीं पता होती. उपयोगकर्ताओं को हमेशा जानकारी दें, ताकि उन्हें पता चल सके कि उनकी कार्रवाइयों का क्या नतीजा निकला! मान लें कि आपका प्रोग्राम, क़र्ज़ के लिए आवेदन करने वाला प्रोग्राम है. "आपको मंज़ूरी नहीं मिली, क्योंकि आपकी क्रेडिट रेटिंग खराब है" यह जानकारी, "माफ़ करें, आपको लोन नहीं मिल सकता. फिर से कोशिश करें!" से ज़्यादा जानकारी देती है. 'लकी डाइस रोलर' के लिए, अगर उपयोगकर्ता हार जाते हैं, तो उन्हें हर रोल के लिए जानकारी देने वाला अलग-अलग मैसेज दिखाया जा सकता है. इसके लिए, एक से ज़्यादा 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 है. अगर ऐसा है, तो 'फिर से कोशिश करें' वाला कोई दूसरा मैसेज प्रिंट करें.
• अगर ऐसा नहीं है, तो पांचवें चरण में बताया गया तरीका अपनाएं.
• अगर संख्या 1 से 5 के बीच नहीं है, तो सिर्फ़ 6 का विकल्प बचता है. इसलिए, else if के साथ किसी और टेस्ट की ज़रूरत नहीं है. साथ ही, आखिरी else स्टेटमेंट के साथ उस आखिरी विकल्प को चुना जा सकता है.

अहम जानकारी: if-else कोड ब्लॉक में, सिर्फ़ एक if स्टेटमेंट और एक else स्टेटमेंट हो सकता है. हालांकि, इनके बीच में ज़रूरत के हिसाब से कई else if स्टेटमेंट हो सकते हैं.

कई else if केस होना बहुत आम बात है. इसलिए, Kotlin में इन्हें लिखने का एक आसान तरीका है.

प्रोग्रामिंग में, अलग-अलग नतीजों या मामलों के लिए टेस्टिंग करना बहुत आम है. कभी-कभी, संभावित नतीजों की सूची बहुत लंबी हो सकती है. उदाहरण के लिए, अगर आपको 12 साइड वाले डाइस को रोल करना है, तो आपको सफलता और फ़ाइनल else के बीच 11 else if स्टेटमेंट मिलेंगे. इस तरह के स्टेटमेंट को लिखना और पढ़ना आसान बनाने के लिए, Kotlin में when स्टेटमेंट उपलब्ध है. इससे गड़बड़ियों से बचने में मदद मिलती है.

आपको अपने प्रोग्राम में when स्टेटमेंट का इस्तेमाल करना है. when स्टेटमेंट, when कीवर्ड से शुरू होता है. इसके बाद, कोष्ठक () होते हैं. कोष्ठक के अंदर, वह वैल्यू डाली जाती है जिसकी जांच करनी है. इसके बाद, कर्ली ब्रैकेट {} का इस्तेमाल किया जाता है. इससे अलग-अलग स्थितियों में कोड को एक्ज़ीक्यूट किया जा सकता है.

1. अपने प्रोग्राम में, पहले if स्टेटमेंट से लेकर आखिरी else स्टेटमेंट को बंद करने वाले कर्ली ब्रेस } तक के कोड को चुनें और उसे मिटा दें.main()

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 स्टेटमेंट का इस्तेमाल करें, ताकि ऐसे मामलों का पता लगाया जा सके जिन्हें साफ़ तौर पर शामिल नहीं किया गया है. अगर आपने छह साइड वाले डाइस के लिए केस कवर किए हैं, तो else स्टेटमेंट, आठ साइड वाले डाइस से रोल किए गए 7 और 8 नंबर को पकड़ लेगा.
• when स्टेटमेंट का इस्तेमाल, किसी वैल्यू की तुलना के आधार पर कोड को लागू करने के लिए किया जाता है.

if-else का सामान्य फ़ॉर्म:

if (condition-is-true) {

execute-this-code

} else if (condition-is-true) {

execute-this-code

} else {

execute-this-code

}

When स्टेटमेंट:

when (variable) {

matches-value -> execute-this-code

matches-value -> execute-this-code

...

}

• Kotlin: कंट्रोल फ़्लो
• Kotlin: when
• शर्तों के आधार पर

ध्यान दें: प्रैक्टिस करना ज़रूरी नहीं है. इनसे आपको इस कोडलैब में सीखी गई बातों को आज़माने का मौका मिलता है. साथ ही, इनमें कभी-कभी कोडिंग से जुड़ी चुनौती भी शामिल होती है.

यह तरीका अपनाएं:

1. myFirstDice को बदलकर 8 साइड करें और कोड चलाएं. इस दिन क्या होगा?

अहम जानकारी: साइड की संख्या बढ़ाने पर, आपका when स्टेटमेंट अब सभी मामलों को कवर नहीं करता है. इसलिए, जिन मामलों को कवर नहीं किया गया है उनके लिए कुछ भी प्रिंट नहीं किया जाता है.

2. when स्टेटमेंट में बदलाव करके, आठों साइड को शामिल करें. इसके लिए, अतिरिक्त नंबरों के लिए केस जोड़े जा सकते हैं. चुनौती: हर नंबर के लिए नया केस जोड़ने के बजाय, else स्टेटमेंट का इस्तेमाल करके उन सभी केस को कैप्चर करें जिनके बारे में साफ़ तौर पर नहीं बताया गया है.

अहम जानकारी: ज़्यादा पहलुओं को शामिल करने के लिए, ज़्यादा केस जोड़े जा सकते हैं. अगर आपको हर नंबर के लिए अलग-अलग मैसेज चाहिए, तो यह तरीका सही है. इसके अलावा, else स्टेटमेंट का इस्तेमाल करके, मौजूदा कोड में शामिल छह से ज़्यादा सभी साइड के लिए एक ही मैसेज प्रिंट किया जा सकता है.

3. myFirstDice को बदलकर सिर्फ़ चार साइड वाला डाइस बनाओ. इस दिन क्या होगा?

अहम जानकारी: डाइस की साइड की संख्या को when स्टेटमेंट में शामिल संख्या से कम करने पर कोई खास असर नहीं पड़ता, क्योंकि इसमें सभी संभावित मामलों को शामिल किया जाता है.