Go में Break: क्या यह switch और select को तोड़ता है? तुलनात्मक विश्लेषण

Break जो कन्फ्यूज करता है: Go ने कैसे बदला switch का पुराना नियम

अगर आपने कभी C, C++, Java या JavaScript में कोड लिखा है, तो आप एक रस्म जानते हैं: switch में हर case के बाद break लगाना ज़रूरी है। वरना — आपका स्वागत है "फॉल-थ्रू" (fall-through) की दुनिया में, जहाँ कोड एक case से दूसरे case में चला जाता है, जब तक उसे break या कंस्ट्रक्शन का अंत न मिल जाए।

अब कल्पना करें: आप Go पर आते हैं, switch लिखते हैं और आदत से हर case के अंत में break लगाते हैं। कोड काम करता है। लेकिन आपके मन में सवाल आता है: "क्या यह ज़रूरी भी है? और अगर मैं इसे हटा दूँ तो क्या होगा?"।

यह सवाल Stack Overflow पर Go सेक्शन में सबसे लोकप्रिय में से एक है। और इसका जवाब शुरुआती लोगों को हैरान करता है: Go में switch और select में break ज़रूरी नहीं है, लेकिन यह मौजूद है और कुछ अलग करता है। आइए उदाहरणों के साथ समझते हैं, ताकि आप कभी कन्फ्यूज़ न हों।

Go vs. C: "उल्टा" switch

क्लासिक C-जैसी भाषाओं में switch इस तरह काम करता है:

// स्यूडो-C कोड\nint x = 2;\nswitch(x) {\n    case 1:\n        printf("एक");\n        break;  // बिना break के — अगले case पर चला जाएगा\n    case 2:\n        printf("दो");\n        break;\n    default:\n        printf("अन्य");\n}\n// आउटपुट: "दो"

case 1 के बाद break हटा दें — और प्रोग्राम "एकदो" प्रिंट करेगा। इस व्यवहार को फॉल-थ्रू कहते हैं, और यह अक्सर बग का कारण बनता है।

Go में फैसला लिया: "बस करो!" डिफ़ॉल्ट रूप से, switch में हर case अपने आप खत्म हो जाता है, और break की ज़रूरत नहीं:

package main\n\nimport "fmt"\n\nfunc main() {\n    x := 2\n    switch x {\n    case 1:\n        fmt.Println("एक")\n        // break की ज़रूरत नहीं — switch से बाहर आ जाएंगे\n    case 2:\n        fmt.Println("दो")\n        // break की ज़रूरत नहीं\n    default:\n        fmt.Println("अन्य")\n    }\n    // आउटपुट: "दो"\n}

लेकिन अगर आप फिर भी break लगाते हैं — कोई बात नहीं, कोड बस switch से पहले ही बाहर निकल जाएगा। हालाँकि अनावश्यक break क्यों लगाएँ, जब यह डिफ़ॉल्ट व्यवहार है?।

फॉल-थ्रू का क्या?

अगर आपको अगले case में "गिरना" है, तो Go एक स्पष्ट कीवर्ड देता है — fallthrough:

switch x {\ncase 1:\n    fmt.Println("एक")\n    fallthrough  // साफ़ कहते हैं: "मैं अगले case में जाना चाहता हूँ"\ncase 2:\n    fmt.Println("दो")\ndefault:\n    fmt.Println("अन्य")\n}\n// x=1 होने पर आउटपुट: "एक" और "दो"

ध्यान दें: fallthrough सिर्फ अगले case के लिए काम करता है, चेन की तरह नहीं। यह जानबूझकर किया गया है ताकि गलती से बग न हों।

Select: मल्टी-चैनल "भाई" switch

Go में एक अनोखी कंस्ट्रक्शन है — select। यह switch जैसी दिखती है, लेकिन सिर्फ चैनलों के साथ काम करती है। और यहाँ भी break मौजूद है, लेकिन एक ट्विस्ट के साथ।

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc main() {\n    ch1 := make(chan string)\n    ch2 := make(chan string)\n\n    go func() {\n        time.Sleep(1 * time.Second)\n        ch1 <- "चैनल 1 से नमस्ते"\n    }()\n    go func() {\n        time.Sleep(2 * time.Second)\n        ch2 <- "चैनल 2 से नमस्ते"\n    }()\n\n    select {\n    case msg1 := <-ch1:\n        fmt.Println(msg1)\n        break  // select से बाहर निकलें\n    case msg2 := <-ch2:\n        fmt.Println(msg2)\n        break  // select से बाहर निकलें\n    case <-time.After(3 * time.Second):\n        fmt.Println("टाइमआउट")\n    }\n}

यहाँ break भी ज़रूरी नहीं है — एक case के निष्पादन के बाद select खत्म हो जाता है। लेकिन इसकी ज़रूरत क्यों है? जवाब: बाहरी लूप से बाहर निकलने के लिए!

Break की असली "खासियत"