प्रोग्रामर 2 के लिए Kotlin बूटकैंप: Kotlin से जुड़ी बुनियादी बातें

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

परिचय

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

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

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

  • IntelliJ IDEA में प्रोजेक्ट बनाने का तरीका
  • IntelliJ IDEA (टूल > Kotlin > Kotlin REPL) में, Kotlin's REPL (Read-Eval-Print लूप) में कोड खोलने और लागू करने का तरीका

आप इन चीज़ों के बारे में जानेंगे

  • 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 का स्टेटमेंट आज़माएं. यह if/else if/else Kotlin में स्टेटमेंट की सीरीज़ लिखने के लिए, when स्टेटमेंट इस्तेमाल करता है, जो कि दूसरी भाषाओं में मौजूद 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

&#t9; अगर 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 में rays होता है. 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 की एक अच्छी सुविधा यह है कि आप उन्हें क्रम में लगाने के बजाय, कोड से शुरू कर सकते हैं. यह उदाहरण आज़माएं:
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. चरणों के अलग-अलग आकार और सीमाएं आज़माएं. आप अंग्रेज़ी के कैरेक्टर के हिसाब से, नंबर या कैरेक्टर की रेंज तय करें. दूसरी लैंग्वेज से अलग, इसमें आपको #39; नहीं बढ़ना चाहिए. आप 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 कोन्स नाम के रिच ट्यूटोरियल शामिल हैं, जो वेब पर आधारित अनुवादक है. साथ ही, इसमें रेफ़रंस दस्तावेज़ का पूरा सेट भी शामिल है, जिसमें उदाहरण भी दिए गए हैं.

Udcity कोर्स

इस विषय पर Udacity कोर्स देखने के लिए, प्रोग्रामर के लिए Kotlin बूटकैंप देखें.

IntelliJ IDEA

JetBrains वेबसाइट पर, InliJ IDEA के दस्तावेज़ देखे जा सकते हैं.

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

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

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

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

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

पहला सवाल

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

▢ 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. फ़ंक्शन

कोर्स के बारे में खास जानकारी पाने के लिए, दूसरे कोडलैब के लिंक के साथ-साथ, &kot;Kotlin बूटकैंपर के लिए प्रोग्राम: कोर्स में आपका स्वागत है.