lateinit और lazy initialization
बाद में असाइन की जाने वाली properties के लिए lateinit और स्थगित computation के लिए by lazy का उपयोग करें।
lateinit और lazy initialization, CoddyKit पर Kotlin Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Kotlin Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Kotlin Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
देर से सेटअप के दो साधन
कभी-कभी आप किसी प्रॉपर्टी को निर्माण के समय आरंभ नहीं कर सकते। Kotlin आपको lateinit (बाद में असाइन की जाने वाली var के लिए) और by lazy (पहली पहुँच पर गणना की जाने वाली val के लिए) देता है।
lateinit की मूल बातें
lateinit var आरंभीकरण को टालता है। यह वेरिएबल नल-रहित, गैर-आदिम var होना चाहिए। असाइनमेंट से पहले पहुँचने पर UninitializedPropertyAccessException उत्पन्न होता है।
class Service {
lateinit var name: String
fun init(value: String) { name = value }
}
fun main() {
val s = Service()
s.init("MyService")
println(s.name)
}lateinit का इस्तेमाल क्यों करें?
lateinit का इस्तेमाल निर्भरता इंजेक्शन, परीक्षण फ़िक्स्चर या फ़्रेमवर्क-प्रबंधित जीवनचक्रों (Android व्यू और Spring बीन्स) के लिए करें, जहाँ आरंभीकरण कन्स्ट्रक्टर के बाहर होता है।
class Repository {
lateinit var db: String // assigned later by DI framework
fun query() = "querying $db"
}
fun main() {
val r = Repository()
r.db = "postgres://localhost"
println(r.query())
}isInitialized जाँच
आप ::propName.isInitialized का इस्तेमाल करके जाँच सकते हैं कि lateinit प्रॉपर्टी को असाइन किया गया है या नहीं।
class Foo {
lateinit var bar: String
fun status() = if (::bar.isInitialized) "set to $bar" else "unset"
}
fun main() {
val f = Foo()
println(f.status()) // unset
f.bar = "hi"
println(f.status())
}lateinit की पाबंदियाँ
आप आदिम प्रकारों (Int, Boolean आदि), नल-योग्य प्रकारों या val पर lateinit का इस्तेमाल नहीं कर सकते। कम्पाइलर इन नियमों को लागू करता है।
// VALID:
lateinit var name: String
// INVALID:
// lateinit var count: Int // primitives not allowed
// lateinit val constant: String // val not allowed
// lateinit var maybe: String? // nullable not allowed
fun main() { name = "ok"; println(name) }by lazy की मूल बातें
by lazy किसी val के आरंभीकरण को पहली पहुँच तक टालता है। लैम्ब्डा एक बार चलती है और परिणाम कैश कर लिया जाता है।
val expensive: String by lazy {
println("Computing...")
"result"
}
fun main() {
println(expensive) // Computing... then result
println(expensive) // result (cached)
}by lazy का इस्तेमाल क्यों करें?
by lazy का इस्तेमाल तब करें जब आरंभीकरण महँगा हो और शायद आवश्यक न हो (इसे बाद में इस्तेमाल के लिए कैश किया जा सके), या जब आरंभीकरण पहले से बनाए गए अन्य प्रॉपर्टीज़ पर निर्भर करता हो।
class Config {
val parsed: Map<String, String> by lazy {
println("parsing config...")
mapOf("host" to "localhost", "port" to "8080")
}
}
fun main() {
val c = Config()
println("config object created — not parsed yet")
println(c.parsed["host"]) // now parses
println(c.parsed["port"]) // cached
}lazy थ्रेड-सुरक्षा मोड
डिफ़ॉल्ट रूप से, by lazy में LazyThreadSafetyMode.SYNCHRONIZED का इस्तेमाल होता है। समवर्ती उपयोग के लिए सुरक्षित आरंभीकरण में PUBLICATION और एकल-थ्रेड प्रदर्शन के लिए NONE का इस्तेमाल करें।
val safe: String by lazy { "thread-safe" }
val fast: String by lazy(LazyThreadSafetyMode.NONE) { "fast, single-thread" }
fun main() {
println(safe)
println(fast)
}lateinit बनाम lazy
lateinit: var, जिसे बाहरी रूप से असाइन किया जाता है। by lazy: val, जिसकी पहली पहुँच पर प्रॉपर्टी स्वयं गणना करती है।
class Demo {
lateinit var injected: String // assigned by caller
val computed: String by lazy { "computed once" }
}
fun main() {
val d = Demo()
d.injected = "from outside"
println(d.injected)
println(d.computed)
}lazy से अन्य प्रॉपर्टीज़ पढ़ना
एक lazy प्रॉपर्टी पहले आरंभ की गई अन्य प्रॉपर्टीज़ को पढ़कर उन्हें संयोजित कर सकती है।
class User(val first: String, val last: String) {
val fullName: String by lazy { "$first $last" }
}
fun main() {
val u = User("Ada", "Lovelace")
println(u.fullName)
}व्यावहारिक पैटर्न
एक ही क्लास में DI के लिए lateinit और व्युत्पन्न स्थिति के लिए by lazy को मिलाएँ।
class App {
lateinit var config: Map<String, String>
val host: String by lazy { config["host"] ?: "localhost" }
}
fun main() {
val app = App()
app.config = mapOf("host" to "api.example.com")
println(app.host) // api.example.com
}त्वरित जाँच
कौन-सा कीवर्ड किसी val प्रॉपर्टी के आरंभीकरण को पहली पहुँच तक टालता है?
पुनरावलोकन
बाद में फ़्रेमवर्क या DI द्वारा असाइन की जाने वाली नल-रहित, परिवर्तनीय प्रॉपर्टीज़ के लिए lateinit var का इस्तेमाल करें। पहली पहुँच पर एक बार गणना किए जाने वाले केवल-पठन मानों के लिए val by lazy का इस्तेमाल करें। स्थिति की जाँच ::prop.isInitialized से करें।
एआई शिक्षक के साथ Kotlin सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 51
- पाठ
- 203
अक्सर पूछे जाने वाले प्रश्न
क्या “lateinit और lazy initialization” पाठ निःशुल्क है?
हाँ — Kotlin Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “lateinit और lazy initialization” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Kotlin Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“lateinit और lazy initialization” में मैं क्या सीखूँगा?
बाद में असाइन की जाने वाली properties के लिए lateinit और स्थगित computation के लिए by lazy का उपयोग करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Kotlin Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Kotlin Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Kotlin Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।
“lateinit और lazy initialization” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Kotlin Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Kotlin Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- प्राथमिक कंस्ट्रक्टर और प्रॉपर्टी पैरामीटर
- init Blocks और initialization का क्रम
- field के साथ कस्टम Getters और Setters
- lateinit और lazy initialization