Kotlin में var और val: क्या अंतर है? पूर्ण विश्लेषण

Kotlin में var और val: क्या अंतर है? पूर्ण विश्लेषण

यदि आप अभी Kotlin में अपनी यात्रा शुरू कर रहे हैं या अन्य भाषाओं (Java, Python, JavaScript) से आए हैं, तो पहले प्रश्नों में से एक जो आप पूछेंगे वह है — वेरिएबल घोषित करने के लिए दो कीवर्ड की आवश्यकता क्यों है? वास्तव में, यदि एक से काम चल सकता है तो जटिल क्यों बनाएं? इसका उत्तर भाषा के दर्शन में निहित है: Kotlin को कोड को सुरक्षित, स्पष्ट और अधिक पूर्वानुमानित बनाने के लिए बनाया गया था। और var और val के बीच का अंतर कोई सनक नहीं है, बल्कि स्थिति प्रबंधन के लिए एक शक्तिशाली उपकरण है।

आइए उदाहरणों के साथ समझते हैं कि var का उपयोग कब करें और val का कब, और यह आपके कोड के लिए क्यों महत्वपूर्ण है।

var और val क्या हैं? मूल परिभाषाएँ

सबसे सरल से शुरू करते हैं।

\n
• var (अंग्रेजी variable से) — परिवर्तनीय वेरिएबल। आप इसे जितनी बार चाहें उतनी बार नया मान असाइन कर सकते हैं।
\n
• val (अंग्रेजी value से) — अपरिवर्तनीय संदर्भ (read-only)। इनिशियलाइज़ेशन के बाद आप इसका मान नहीं बदल सकते। यह Java में final या JavaScript में const (कुछ शर्तों के साथ) के समान है।
\n

यहाँ सबसे सरल उदाहरण है:

fun main() {\n    var x = 10\n    x = 20 // OK: var को बदला जा सकता है\n\n    val y = 30\n    // y = 40 // कंपाइलेशन त्रुटि: val को पुनः असाइन नहीं किया जा सकता\n\n    println("x = $x, y = $y")\n}

सब कुछ स्पष्ट लगता है, लेकिन शैतान, हमेशा की तरह, विवरण में है।

मुख्य अंतर: संदर्भ की परिवर्तनीयता बनाम ऑब्जेक्ट की परिवर्तनीयता

यहाँ अक्सर भ्रम होता है। val गारंटी देता है कि ऑब्जेक्ट का संदर्भ नहीं बदलेगा, लेकिन यह ऑब्जेक्ट की अपरिवर्तनीयता की गारंटी नहीं देता।

आइए एक सूची के उदाहरण से समझते हैं:

fun main() {\n    val numbers = mutableListOf(1, 2, 3)\n    // numbers = mutableListOf(4, 5, 6) // त्रुटि: val को पुनः असाइन नहीं किया जा सकता\n\n    numbers.add(4) // लेकिन ऐसा किया जा सकता है! हम ऑब्जेक्ट की सामग्री बदल रहे हैं\n    numbers[0] = 100 // और ऐसा भी किया जा सकता है\n\n    println(numbers) // [100, 2, 3, 4]\n}

ध्यान दें: हमने numbers को val के रूप में घोषित किया, लेकिन हम आसानी से तत्वों को जोड़ और बदल रहे हैं। क्यों? क्योंकि val केवल संदर्भ (वेरिएबल numbers) की रक्षा करता है, न कि उस ऑब्जेक्ट की जिस पर वह इंगित करता है।

यदि आप पूर्ण अपरिवर्तनीयता चाहते हैं, तो आपको अपरिवर्तनीय कलेक्शन (listOf, mapOf, setOf) और val का एक साथ उपयोग करना होगा।

fun main() {\n    val immutableNumbers = listOf(1, 2, 3)\n    // immutableNumbers.add(4) // त्रुटि: listOf एक अपरिवर्तनीय सूची लौटाता है\n    // immutableNumbers[0] = 100 // त्रुटि\n}

यह एक महत्वपूर्ण बिंदु है जो अक्सर साक्षात्कार में पूछा जाता है। याद रखें: val ≠ immutable object।

var का उपयोग कब करें और val का कब?

Kotlin का सुनहरा नियम: जहाँ संभव हो वहाँ val का उपयोग करें, और var का केवल तभी उपयोग करें जब वास्तव में आवश्यक हो। क्यों?

\n
• सुरक्षा। जितने कम परिवर्तनीय वेरिएबल होंगे, किसी अप्रत्याशित स्थान पर मान गलती से बदलने की संभावना उतनी ही कम होगी। यह विशेष रूप से मल्टीथ्रेडेड प्रोग्रामिंग में महत्वपूर्ण है।
\n
• पठनीयता। जब आप val देखते हैं, तो आप तुरंत जान जाते हैं कि मान नहीं बदलेगा। यह कोड को समझना आसान बनाता है।
\n
• कार्यात्मक शैली। Kotlin कार्यात्मक प्रोग्रामिंग को प्रोत्साहित करता है, जहाँ अपरिवर्तनीयता प्रमुख सिद्धांतों में से एक है।
\n

यहाँ एक उदाहरण है जहाँ var उचित है:

fun main() {\n    var counter = 0\n    while (counter < 10) {\n        println("Counter: $counter")\n        counter++ // काउंटर को बदलना होगा\n    }\n}

और यहाँ एक उदाहरण है जहाँ var एक खराब प्रथा है, और इसे बदला जा सकता है