प्रोग्रामर के लिए Kotlin Bootcamp 2: Kotlin की बुनियादी बातें

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

परिचय

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

इस कोर्स में, एक सैंपल ऐप्लिकेशन बनाने के बजाय, अलग-अलग विषयों पर जानकारी दी गई है. हालांकि, ये विषय एक-दूसरे से जुड़े हुए हैं, लेकिन इन्हें इस तरह से डिज़ाइन किया गया है कि आप अपनी ज़रूरत के हिसाब से किसी भी विषय को पढ़ सकें. इन सभी उदाहरणों को एक साथ दिखाने के लिए, इनमें ऐक्वेरियम की थीम का इस्तेमाल किया गया है. अगर आपको एक्वेरियम की पूरी कहानी देखनी है, तो Udacity पर प्रोग्रामर के लिए Kotlin बूटकैंप कोर्स देखें.

आपको पहले से क्या पता होना चाहिए

  • IntelliJ IDEA में प्रोजेक्ट बनाने का तरीका
  • IntelliJ IDEA में, Kotlin के REPL (Read-Eval-Print Loop) में कोड खोलने और उसे चलाने का तरीका (Tools > Kotlin > Kotlin REPL)

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

  • Kotlin के डेटा टाइप, ऑपरेटर, और वैरिएबल का इस्तेमाल कैसे करें
  • बूलियन और शर्तों के साथ काम करने का तरीका
  • शून्य हो सकने वाले और शून्य नहीं हो सकने वाले वैरिएबल के बीच अंतर
  • Kotlin में ऐरे, सूचियां, और लूप कैसे काम करते हैं

आपको क्या करना होगा

  • Kotlin की बुनियादी बातें जानने के लिए, Kotlin REPL का इस्तेमाल करना

इस टास्क में, आपको Kotlin प्रोग्रामिंग लैंग्वेज में ऑपरेटर और टाइप के बारे में जानकारी मिलेगी.

पहला चरण: संख्या वाले ऑपरेटर के बारे में जानना

  1. अगर IntelliJ IDEA पहले से खुला हुआ नहीं है, तो इसे खोलें.
  2. Kotlin REPL खोलने के लिए, टूल > Kotlin > Kotlin REPL चुनें.

अन्य लैंग्वेज की तरह, Kotlin में जोड़ने, घटाने, गुणा करने, और भाग देने के लिए +, -, *, और / का इस्तेमाल होता है. Kotlin अलग-अलग तरह के नंबर टाइप के साथ काम करता है, जैसे कि Int, Long, Double, और Float.

  1. REPL में ये एक्सप्रेशन डालें. नतीजा देखने के लिए, हर एक के बाद Control+Enter (Mac पर Command+Enter) दबाएं.
1+1
⇒ res8: kotlin.Int = 2

53-3
⇒ res9: kotlin.Int = 50

50/10
⇒ res10: kotlin.Int = 5

1.0/2.0
⇒ res11: kotlin.Double = 0.5

2.0*3.5
⇒ res12: kotlin.Double = 7.0

ध्यान दें कि ऑपरेंड टाइप वाले ऑपरेशन के नतीजे, इसलिए 1/2 = 0, लेकिन 1.0/2.0 = 0.5 होगा.

  1. पूर्णांक और दशमलव संख्याओं के अलग-अलग कॉम्बिनेशन वाले कुछ एक्सप्रेशन आज़माएं.
6*50
⇒ res13: kotlin.Int = 300

6.0*50.0
⇒ res14: kotlin.Double = 300.0

6.0*50
⇒ res15: kotlin.Double = 300.0
  1. नंबरों पर कुछ तरीकों को कॉल करें. Kotlin, नंबर को प्रिमिटिव रखती है. हालांकि, आपके पास नंबर पर ऑब्जेक्ट की तरह मेथड कॉल करने का विकल्प होता है.
2.times(3)
⇒ res5: kotlin.Int = 6

3.5.plus(4)
⇒ res8: kotlin.Double = 7.5

2.4.div(2)
⇒ res9: kotlin.Double = 1.2

दूसरा चरण: टाइप का इस्तेमाल करने का तरीका सीखना

Kotlin में, इंप्लिसिट तरीके से नंबर टाइप को आपस में नहीं बदला जाता है. इस वजह से, हो सकता है कि आप शॉर्ट वैल्यू को सीधे तौर पर लॉन्ग वैरिएबल पर या Byte को Int पर असाइन न कर पाएं. ऐसा इसलिए होता है, क्योंकि प्रोग्राम में आम तौर पर, इंप्लिसिट नंबर कन्वर्ज़न की वजह से गड़बड़ियां होती हैं. कास्टिंग करके, अलग-अलग टाइप की वैल्यू असाइन की जा सकती हैं.

  1. REPL में Int टाइप का वैरिएबल तय करके, कुछ संभावित कास्ट देखी जा सकती हैं.
val i: Int = 6
  1. नया वैरिएबल बनाएं. इसके बाद, ऊपर दिखाया गया वैरिएबल का नाम डालें. इसके बाद, .to डालें.
val b1 = i.to

IntelliJ IDEA, टाइप करते समय पूरा कोड लिखने के सुझावों की सूची दिखाता है. अपने-आप पूरा होने की यह सुविधा, किसी भी टाइप के वैरिएबल और ऑब्जेक्ट के लिए काम करती है.

  1. सूची से toByte() चुनें. इसके बाद, वैरिएबल प्रिंट करें.
val b1 = i.toByte()
println(b1)
 
⇒ 6
  1. अलग-अलग टाइप के वैरिएबल के लिए, Byte वैल्यू असाइन करें.
val b2: Byte = 1 // OK, literals are checked statically
println(b2)
⇒ 1

val i1: Int = b2
⇒ error: type mismatch: inferred type is Byte but Int was expected

val i2: String = b2
⇒ error: type mismatch: inferred type is Byte but String was expected

val i3: Double = b2
⇒ error: type mismatch: inferred type is Byte but Double was expected
  1. जिन असाइनमेंट में गड़बड़ियां हुई हैं उन्हें कास्ट करके देखें.
val i4: Int = b2.toInt() // OK!
println(i4)
⇒ 1

val i5: String = b2.toString()
println(i5)
⇒ 1

val i6: Double = b2.toDouble()
println(i6)
⇒ 1.0
  1. लंबे न्यूमेरिक कॉन्सटेंट को पढ़ने में आसान बनाने के लिए, Kotlin आपको संख्याओं में अंडरस्कोर लगाने की अनुमति देता है. हालांकि, आपको यह तय करना होगा कि अंडरस्कोर कहां लगाना है. अलग-अलग संख्यात्मक स्थिरांक डालकर देखें.
val oneMillion = 1_000_000
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

तीसरा चरण: वैरिएबल टाइप की वैल्यू के बारे में जानना

Kotlin दो तरह के वैरिएबल के साथ काम करती है: बदले जा सकने वाले और नहीं बदले जा सकने वाले. val से, वैल्यू को एक बार असाइन किया जा सकता है. किसी आइटम को फिर से असाइन करने पर, आपको गड़बड़ी का मैसेज मिलेगा. var में, आपके पास वैल्यू असाइन करने की सुविधा है और प्रोग्राम में आगे कभी वैल्यू को बदला जा सकता है.

  1. val और var का इस्तेमाल करके वैरिएबल तय करें. इसके बाद, उन्हें नई वैल्यू असाइन करें.
var fish = 1
fish = 2
val aquarium = 1
aquarium = 2
 
⇒ error: val cannot be reassigned

fish को एक वैल्यू असाइन करके, उसे नई वैल्यू असाइन करें. ऐसा इसलिए, क्योंकि यह var से तय होता है. aquarium को नई वैल्यू असाइन करने पर गड़बड़ी का मैसेज दिखता है, क्योंकि यह val से तय होता है.

जो टाइप वैरिएबल में सेव किया जाता है उसका अनुमान तब लगाया जाता है, जब कंपाइलर कॉन्टेक्स्ट से उसका पता लगा ले. अगर आप चाहें, तो कोलन नोटेशन का इस्तेमाल करके, वैरिएबल का टाइप तय करें.

  1. कुछ वैरिएबल तय करें और उनका टाइप साफ़ तौर पर बताएं.
var fish: Int = 12
var lakes: Double = 2.5

एक बार जब आप या कंपाइलर से कोई टाइप असाइन कर दें, तो उस टाइप को बदला नहीं जा सकता. टाइप बदलने की कोशिश करने पर आपको गड़बड़ी का मैसेज मिलेगा.

चौथा चरण: स्ट्रिंग के बारे में जानकारी

Kotlin में स्ट्रिंग किसी भी अन्य प्रोग्रामिंग लैंग्वेज वाली स्ट्रिंग की तरह काम करती हैं. इनमें स्ट्रिंग के लिए " और एक कैरेक्टर के लिए ' का इस्तेमाल होता है. साथ ही, आपके पास + ऑपरेटर से स्ट्रिंग जोड़ने की सुविधा होती है. स्ट्रिंग टेंप्लेट बनाने के लिए, उन्हें वैल्यू के साथ जोड़ें. $variable नाम को वैल्यू दिखाने वाले टेक्स्ट से बदल दिया जाता है. इसे वैरिएबल इंटरपोलेशन कहते हैं.

  1. स्ट्रिंग टेंप्लेट बनाएं.
val numberOfFish = 5
val numberOfPlants = 12
"I have $numberOfFish fish" + " and $numberOfPlants plants"
 
⇒ res20: kotlin.String = I have 5 fish and 12 plants
  1. एक्सप्रेशन वाला स्ट्रिंग टेंप्लेट बनाएं. अन्य लैंग्वेज में, वैल्यू किसी एक्सप्रेशन का नतीजा हो सकती है. एक्सप्रेशन तय करने के लिए, कर्ली ब्रैकेट {} का इस्तेमाल करें. 
"I have ${numberOfFish + numberOfPlants} fish and plants"
 
⇒ res21: kotlin.String = I have 17 fish and plants

इस टास्क में, आपको Kotlin प्रोग्रामिंग लैंग्वेज में बूलियन और शर्तों की जांच करने के बारे में जानकारी मिलेगी. अन्य भाषाओं की तरह, Kotlin में बूलियन और बूलियन ऑपरेटर होते हैं. जैसे, इससे कम, इसके बराबर, इससे ज़्यादा वगैरह (<, ==, >, !=, <=, >=).

  1. if/else स्टेटमेंट लिखें.
val numberOfFish = 50
val numberOfPlants = 23
if (numberOfFish > numberOfPlants) {
    println("Good ratio!") 
} else {
    println("Unhealthy ratio")
}
 
⇒ Good ratio!
  1. if स्टेटमेंट में कोई रेंज आज़माएं. Kotlin में, जिस कंडीशन की जांच की जाती है वह रेंज का इस्तेमाल भी कर सकती है. 
val fish = 50
if (fish in 1..100) {
    println(fish)
}
 
⇒ 50
  1. कई केस वाला if लिखो. ज़्यादा मुश्किल शर्तों के लिए, लॉजिकल ऐंड && और लॉजिकल ऑर || का इस्तेमाल करें. अन्य लैंग्वेज की तरह, else if के इस्तेमाल से कई केस मिल सकते हैं. 
if (numberOfFish == 0) {
    println("Empty tank")
} else if (numberOfFish < 40) {
    println("Got fish!")
} else {
    println("That's a lot of fish!")
}
 
⇒ That's a lot of fish!
  1. when स्टेटमेंट का इस्तेमाल करके देखें. Kotlin में when स्टेटमेंट का इस्तेमाल करके, if/else if/else स्टेटमेंट की सीरीज़ को बेहतर तरीके से लिखा जा सकता है. यह अन्य भाषाओं में switch स्टेटमेंट की तरह होता है. when स्टेटमेंट की कंडीशन भी रेंज का इस्तेमाल कर सकती हैं. 
when (numberOfFish) {
    0  -> println("Empty tank")
    in 1..39 -> println("Got fish!")
    else -> println("That's a lot of fish!")
}
 
⇒ That's a lot of fish!

इस टास्क में, आपको शून्य हो सकने वाले वैरिएबल और शून्य नहीं हो सकने वाले वैरिएबल के बारे में जानकारी मिलेगी. शून्य वाली 'प्रोग्रामिंग गड़बड़ियों' से, कई गड़बड़ियां होती हैं. Kotlin, शून्य नहीं हो सकने वाले वैरिएबल से गड़बड़ियों को कम करती है.

पहला चरण: नल वैल्यू के बारे में जानना

डिफ़ॉल्ट रूप से, वैरिएबल null नहीं हो सकते.

  1. Int तय करें और उस पर null असाइन करें.
var rocks: Int = null
 
⇒ error: null can not be a value of a non-null type Int
  1. टाइप के बाद प्रश्न चिह्न ऑपरेटर, ? का इस्तेमाल करके यह बताएं कि कोई वैरिएबल शून्य हो सकता है. Int? तय करें और उस पर null असाइन करें.
var marbles: Int? = null

जब आपके पास सूची जैसे जटिल डेटा टाइप होते हैं, तो:

  • आप सूची के एलिमेंट को शून्य होने दे सकते हैं.
  • आप सूची को शून्य होने दे सकते हैं. हालांकि, अगर सूची शून्य नहीं है, तो उसके एलिमेंट शून्य नहीं हो सकते.
  • आप सूची या एलिमेंट दोनों को शून्य होने दे सकते हैं.

सूचियों और कुछ अन्य जटिल डेटा टाइप के बारे में, बाद के टास्क में बताया गया है.

दूसरा चरण: ? के बारे में जानें और ?: ऑपरेटर

? ऑपरेटर की मदद से, null की जांच की जा सकती है. इससे आपको कई if/else स्टेटमेंट लिखने में लगने वाला समय बचता है.

  1. यह देखने के लिए कि fishFoodTreats वैरिएबल null नहीं है, कुछ कोड को लंबे तरीके से लिखें. इसके बाद, उस वैरिएबल को घटाएं.
var fishFoodTreats = 6
if (fishFoodTreats != null) {
    fishFoodTreats = fishFoodTreats.dec()
}
  1. अब ? ऑपरेटर का इस्तेमाल करके, इसे Kotlin में लिखने का तरीका देखें.
var fishFoodTreats = 6
fishFoodTreats = fishFoodTreats?.dec()
  1. ?: ऑपरेटर की मदद से, 'चेन शून्य' की जांच भी की जा सकती है. इस उदाहरण पर एक नज़र डालें:
fishFoodTreats = fishFoodTreats?.dec() ?: 0

यह "अगर fishFoodTreats, null नहीं है, तो इसे घटाने के बाद इस्तेमाल करें. अगर ऐसा नहीं है, तो ?: के बाद की वैल्यू इस्तेमाल करें, जो कि 0 है" का शॉर्टहैंड है. अगर fishFoodTreats null है, तो जांच बंद हो जाती है और dec() मेथड का इस्तेमाल नहीं होता.

नल पॉइंटर के बारे में जानकारी

अगर आपको वाकई NullPointerExceptions पसंद है, तो आप उसे Kotlin में रखें. गैर-शून्य के दावे वाला ऑपरेटर, !! (डबल-बैंग), हर वैल्यू को गैर-शून्य टाइप में बदल देता है और वैल्यू के null होने पर अपवाद देता है.

val len = s!!.length   // throws NullPointerException if s is null

इस टास्क में, आपको ऐरे और सूचियों के बारे में जानकारी मिलेगी. साथ ही, Kotlin प्रोग्रामिंग भाषा में लूप बनाने के अलग-अलग तरीकों के बारे में भी जानकारी मिलेगी.

पहला चरण: सूचियां बनाना

Kotlin में लिस्ट एक बुनियादी टाइप है. यह अन्य लैंग्वेज में मौजूद लिस्ट की तरह ही होती है.

  1. listOf का इस्तेमाल करके, सूची बताएं और उसे प्रिंट करें. इस सूची में बदलाव नहीं किया जा सकता. 
val school = listOf("mackerel", "trout", "halibut")
println(school)
 
⇒ [mackerel, trout, halibut]
  1. mutableListOf का इस्तेमाल करके, ऐसी सूची बनाएं जिसमें बदलाव किया जा सके. कोई आइटम हटाएं.
val myList = mutableListOf("tuna", "salmon", "shark")
myList.remove("shark")
 
⇒ res36: kotlin.Boolean = true

पास किए गए आइटम को हटाने पर, remove() मेथड true दिखाता है.

दूसरा चरण: अरे बनाना

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

सूचियों और ऐरे में, val और var को इस्तेमाल करने के नियम एक हैं.

  1. arrayOf का इस्तेमाल करके, स्ट्रिंग की श्रेणी तय करें. इसे प्रिंट करने के लिए, java.util.Arrays.toString() श्रेणी की उपयोगिता का इस्तेमाल करें. 
val school = arrayOf("shark", "salmon", "minnow")
println(java.util.Arrays.toString(school))
 
⇒ [shark, salmon, minnow]
  1. arrayOf से तय की गई श्रेणी में, एलिमेंट से जुड़ा कोई टाइप नहीं होता. इसलिए, अलग-अलग टाइप को एक साथ इस्तेमाल किया जा सकता है. यह फ़ायदेमंद होता है. अलग-अलग टाइप वाली एक कैटगरी तय करें.
val mix = arrayOf("fish", 2)
  1. सभी एलिमेंट के लिए एक टाइप की श्रेणियां भी तय की जा सकती हैं. intArrayOf() का इस्तेमाल करके, पूर्णांकों की एक कैटगरी तय करें. दूसरे टाइप वाली श्रेणियों के लिए, संबंधित बिल्डर या इंस्टैंशिएशन फ़ंक्शन हैं.
val numbers = intArrayOf(1,2,3)
  1. + ऑपरेटर की मदद से, दो ऐरे को जोड़ें.
val numbers = intArrayOf(1,2,3)
val numbers3 = intArrayOf(4,5,6)
val foo2 = numbers3 + numbers
println(foo2[5])
 
=> 3
  1. नेस्ट की गई ऐरे और सूचियों के अलग-अलग कॉम्बिनेशन आज़माएं. अन्य भाषाओं की तरह, इसमें भी ऐरे और सूचियों को नेस्ट किया जा सकता है. इसका मतलब है कि जब किसी कलेक्शन में कोई दूसरा कलेक्शन शामिल किया जाता है, तो आपको कलेक्शन का कलेक्शन मिलता है. हालांकि, आपको दोनों कलेक्शन के कॉन्टेंट का फ़्लैट किया गया कलेक्शन नहीं मिलता. किसी ऐरे के एलिमेंट, सूचियां भी हो सकती हैं. साथ ही, सूचियों के एलिमेंट, ऐरे हो सकते हैं. 
val numbers = intArrayOf(1, 2, 3)
val oceans = listOf("Atlantic", "Pacific")
val oddList = listOf(numbers, oceans, "salmon")
println(oddList)
 
⇒ [[I@89178b4, [Atlantic, Pacific], salmon]

पहला एलिमेंट, numbers, एक Array है. जब इसे प्रिंट करने के लिए ऐरे यूटिलिटी का इस्तेमाल नहीं किया जाता है, तो Kotlin ऐरे के कॉन्टेंट के बजाय पता प्रिंट करता है.

  1. Kotlin की एक अच्छी सुविधा यह है कि इसमें ऐरे को 0 पर सेट करने के बजाय, कोड की मदद से सेट किया जा सकता है. यह उदाहरण आज़माएँ:
val array = Array (5) { it * 2 }
println(java.util.Arrays.toString(array))
 
⇒ [0, 2, 4, 6, 8]

शुरू करने का कोड, कर्ली ब्रेसिज़ {} के बीच में होता है. कोड में, it का मतलब ऐरे इंडेक्स से है. इसकी शुरुआत 0 से होती है.

तीसरा चरण: लूप बनाना

अब आपके पास सूचियां और ऐरे हैं. इसलिए, ऐलिमेंट के ज़रिए लूपिंग, आपकी उम्मीद के मुताबिक काम करती है.

  1. एक अरे बनाएं. ऐरे में मौजूद एलिमेंट को प्रिंट करने के लिए, for लूप का इस्तेमाल करें.
val school = arrayOf("shark", "salmon", "minnow")
for (element in school) {
    print(element + " ")
}
 
⇒ shark salmon minnow
  1. Kotlin में, एक साथ एलिमेंट और इंडेक्स से लूप किया जा सकता है. यह उदाहरण आज़माएँ:
for ((index, element) in school.withIndex()) {
    println("Item at $index is $element\n")
}
 
⇒ Item at 0 is shark
Item at 1 is salmon
Item at 2 is minnow
  1. अलग-अलग स्टेप साइज़ और रेंज आज़माएं. अंग्रेज़ी के कैरेक्टर के हिसाब से, नंबर या कैरेक्टर की रेंज तय करें. दूसरी लैंग्वेज से अलग, इसमें आपको एक स्टेप आगे नहीं बढ़ना पड़ता है. downTo का इस्तेमाल करके, पीछे जाया जा सकता है.
for (i in 1..5) print(i)
⇒ 12345

for (i in 5 downTo 1) print(i)
⇒ 54321

for (i in 3..6 step 2) print(i)
⇒ 35

for (i in 'd'..'g') print (i)
⇒ defg
  1. कुछ लूप आज़माएँ. अन्य लैंग्वेज की तरह, Kotlin में while लूप, do...while लूप, और ++ और -- ऑपरेटर होते हैं. Kotlin में repeat लूप भी होते हैं.
var bubbles = 0
while (bubbles < 50) {
    bubbles++
}
println("$bubbles bubbles in the water\n")

do {
    bubbles--
} while (bubbles > 50)
println("$bubbles bubbles in the water\n")

repeat(2) {
     println("A fish is swimming")
}
 
⇒ 50 bubbles in the water
49 bubbles in the water
A fish is swimmingA fish is swimming

ऑपरेटर, सूचियों, और लूप जैसे बुनियादी कॉन्सेप्ट के मामले में, Kotlin अन्य भाषाओं से काफ़ी मिलती-जुलती है. हालांकि, इनमें कुछ अहम अंतर हैं.

Kotlin में, यहाँ बताई गई सुविधाएँ अन्य भाषाओं से अलग हो सकती हैं:

  • Kotlin टाइप को इंप्लिसिट तरीके से नहीं बदला जा सकता. इसलिए, कास्टिंग का इस्तेमाल करें.
  • val के साथ डिक्लेयर किए गए वैरिएबल को सिर्फ़ एक बार असाइन किया जा सकता है.
  • Kotlin वैरिएबल, डिफ़ॉल्ट रूप से शून्य नहीं हो सकते. वैरिएबल को नल वैल्यू असाइन करने की अनुमति देने के लिए, ? का इस्तेमाल करें.
  • Kotlin में, for लूप में एक साथ किसी ऐरे के इंडेक्स और एलिमेंट से लूप किया जा सकता है.

Kotlin प्रोग्रामिंग के ये कंस्ट्रक्ट, अन्य भाषाओं में मौजूद कंस्ट्रक्ट के जैसे ही होते हैं:

  • ऐरे और सूचियों में एक टाइप या अलग-अलग टाइप हो सकते हैं.
  • ऐरे और सूचियों को नेस्ट किया जा सकता है.
  • for, while, do/while, और repeat की मदद से लूप बनाए जा सकते हैं.
  • when स्टेटमेंट, switch स्टेटमेंट का Kotlin वर्शन है. हालांकि, when ज़्यादा सुविधाजनक है.

Kotlin का दस्तावेज़

अगर आपको इस कोर्स के किसी विषय के बारे में ज़्यादा जानकारी चाहिए या आपको कोई समस्या आ रही है, तो https://kotlinlang.org पर जाएं.

Kotlin के ट्यूटोरियल

https://try.kotlinlang.org वेबसाइट पर, Kotlin Koans नाम के रिच ट्यूटोरियल, वेब पर आधारित इंटरप्रेटर, और उदाहरणों के साथ रेफ़रंस दस्तावेज़ों का पूरा सेट शामिल है.

Udacity कोर्स

इस विषय पर Udacity का कोर्स देखने के लिए, Kotlin Bootcamp for Programmers पर जाएं.

IntelliJ IDEA

IntelliJ IDEA के लिए दस्तावेज़, JetBrains की वेबसाइट पर उपलब्ध हैं.

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

  • अगर ज़रूरी हो, तो होमवर्क असाइन करें.
  • छात्र-छात्राओं को बताएं कि होमवर्क असाइनमेंट कैसे सबमिट किए जाते हैं.
  • होमवर्क असाइनमेंट को ग्रेड दें.

शिक्षक इन सुझावों का इस्तेमाल अपनी ज़रूरत के हिसाब से कर सकते हैं. साथ ही, वे चाहें, तो कोई दूसरा होमवर्क भी दे सकते हैं.

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

इन सवालों के जवाब दें

पहला सवाल

इनमें से कौनसा विकल्प, स्ट्रिंग की ऐसी सूची बनाता है जिसे बदला नहीं जा सकता?

▢ val school = arrayOf("shark", "salmon", "minnow")

▢ var school = arrayOf("shark", "salmon", "minnow")

▢ val school = listOf("shark", "salmon", "minnow")

▢ val school = mutableListOf("shark", "salmon", "minnow")

दूसरा सवाल

इस कोड का आउटपुट क्या होगा?
for (i in 3..8 step 2) print(i)

▢ 345678

▢ 468

▢ 38

▢ 357

तीसरा सवाल

इस कोड में प्रश्न चिह्न का क्या मतलब है?
var rocks: Int? = 3

▢ वैरिएबल rocks का टाइप तय नहीं है.

▢ वैरिएबल rocks को शून्य पर सेट किया जा सकता है.

▢ वैरिएबल rocks को शून्य पर सेट नहीं किया जा सकता.

▢ वैरिएबल rocks को तुरंत शुरू नहीं किया जाना चाहिए.

अगले लेसन पर जाएं: 3. फ़ंक्शन

कोर्स की खास जानकारी और अन्य कोडलैब के लिंक देखने के लिए, "प्रोग्रामर के लिए Kotlin बूटकैंप: कोर्स में आपका स्वागत है." लेख पढ़ें