Kotlin switch-case: when कैसे काम करता है अंदरूनी तौर पर? पूरी गाइड

परिचय: अलविदा, switch-case? स्वागत है when!

अगर आप Java, C# या JavaScript की दुनिया से Kotlin में आए हैं, तो सबसे पहले आप शायद परिचित ऑपरेटर switch-case की तलाश करेंगे। और यहाँ आपको एक सरप्राइज मिलेगा: Kotlin में कोई क्लासिक switch-case नहीं है। इसके बजाय, भाषा एक अधिक शक्तिशाली और लचीला उपकरण प्रदान करती है — when।

Stack Overflow पर प्रश्न "How to implement switch-case statement in Kotlin" हजारों बार देखा जाता है। यह सामान्य है: डेवलपर्स कुछ संरचनाओं के आदी होते हैं और उनके समकक्ष खोजना चाहते हैं। लेकिन सच्चाई यह है कि Kotlin में when केवल switch का प्रतिस्थापन नहीं है। यह इसका विकास है, जो अंदरूनी तौर पर अधिक समझदारी और तेजी से काम करता है।

इस लेख में हम केवल when लिखने का तरीका नहीं दिखाएंगे। हम अंदरूनी तौर पर देखेंगे: जानेंगे कि आपका कोड किसमें कंपाइल होता है, यह कुछ परिदृश्यों में switch से तेज क्यों है, और when का 100% उपयोग कैसे करें।

1. मूल सिंटैक्स: switch-case से when तक

शुरुआत के लिए — सबसे सरल उदाहरण। मान लीजिए हमारे पास पुरानी अच्छी Java संरचना है:

// Java\nint day = 3;\nString dayName;\nswitch (day) {\n    case 1:\n        dayName = "सोमवार";\n        break;\n    case 2:\n        dayName = "मंगलवार";\n        break;\n    case 3:\n        dayName = "बुधवार";\n        break;\n    default:\n        dayName = "अज्ञात दिन";\n}

Kotlin में यह इस तरह दिखेगा:

// Kotlin\nval day = 3\nval dayName = when (day) {\n    1 -> "सोमवार"\n    2 -> "मंगलवार"\n    3 -> "बुधवार"\n    else -> "अज्ञात दिन"\n}

यहाँ पहले से ही दो मुख्य लाभ दिखाई देते हैं:

\n
• कोई break नहीं — Kotlin शाखा निष्पादित करने के बाद स्वचालित रूप से ब्लॉक से बाहर निकलता है।
\n
• मान लौटाता है — परिणाम को एक वेरिएबल को सौंपा जा सकता है।
\n

2. when अंदरूनी तौर पर कैसे काम करता है: बाइट-कोड और अनुकूलन

अब सबसे दिलचस्प बात। जब आप when लिखते हैं, Kotlin कंपाइलर आपकी शर्तों का विश्लेषण करता है और निष्पादन का सबसे अच्छा तरीका चुनता है। आइए बाइट-कोड में झांकें (लगभग, अनावश्यक विवरण के बिना)।

केस 1: स्थिरांक के साथ when (switch-case की तरह)

यदि आप पूर्णांक, स्ट्रिंग या enum स्थिरांक के साथ when का उपयोग करते हैं, तो कंपाइलर एक ट्रांज़िशन टेबल (tableswitch या lookupswitch) उत्पन्न करता है। यह वही तंत्र है जो Java switch-case के लिए उपयोग करता है। अंतर यह है कि Kotlin इसे स्वचालित रूप से करता है, आपकी भागीदारी के बिना।

केस 2: किसी भी शर्त के साथ when

यदि आप कुछ इस तरह लिखते हैं:

when (x) {\n    in 1..10 -> "छोटा"\n    in 11..100 -> "मध्यम"\n    else -> "बड़ा"\n}

कंपाइलर ट्रांज़िशन टेबल का उपयोग नहीं कर सकता। वह if-else की एक श्रृंखला उत्पन्न करता है। लेकिन Kotlin इसे अधिकतम कुशलता से करता है: शर्तों को क्रम में जांचा जाता है, और जैसे ही कोई मिलान मिलता है, निष्पादन रुक जाता है।

केस 3: बिना तर्क के when

यह तो बिल्कुल अलग जादू है। यदि आप लिखते हैं:

when {\n    x > 0 -> "सकारात्मक"\n    x < 0 -> "नकारात्मक"\n    else -> "शून्य"\n}

कंपाइलर इसे सामान्य if-else में बदल देता है। लेकिन सिंटैक्स नेस्टेड if की तुलना में कहीं अधिक साफ है।

निष्कर्ष: Kotlin केवल switch-case की नकल नहीं करता। यह आपके कोड को अधिकतम तेजी से चलाने के लिए ट्रांज़िशन टेबल और if-else के बीच समझदारी से चुनाव करता है।

3. when की उन्नत क्षमताएँ: जो switch में नहीं हैं

when केवल मानों की तुलना करने से कहीं अधिक कर सकता है। यहाँ कुछ killer-फीचर्स हैं:

3.1. प्रकार की जाँच (स्मार्ट कास्ट)

fun describe(obj: Any): String = when (obj) {\n    is String -> "${obj.length} लंबाई वाली स्ट्रिंग"  // स्मार्ट कास्ट से String\n    is Int -> "पूर्णांक"\n    is List<*> -> "${obj.size} तत्वों वाली सूची"\n    else -> "अज्ञात प्रकार"\n}

3.2. रेंज और कलेक्शन