Go बनाम Python: क्या Go में "if x in" कंस्ट्रक्ट है?

परिचय: Python प्रोग्रामर Go में "in" को क्यों मिस करते हैं?

यदि आप Python की दुनिया से Go में आए हैं, तो आपको वह जादुई पंक्ति याद होगी: if "banana" in fruits:। छोटा, सुरुचिपूर्ण, पढ़ने योग्य। और फिर आप Go खोलते हैं और सवाल पूछते हैं: "Does Go have 'if x in' construct similar to Python?" — Stack Overflow पर यह सबसे लोकप्रिय प्रश्न है, जिसने हजारों व्यूज एकत्र किए हैं।

स्पॉयलर: Go में in जैसा कोई सीधा सिंटैक्टिक शुगर नहीं है। लेकिन इसका मतलब यह नहीं है कि समस्या हल नहीं होती या मुश्किल से हल होती है। इसके विपरीत, Go में सदस्यता जांच के कई मुहावरेदार तरीके हैं, जिनमें से प्रत्येक अपने तरीके से कुशल और सुंदर है।

इस लेख में हम चर्चा करेंगे:

\n
• Go में in क्यों नहीं है और भाषा के दर्शन ने इसे कैसे प्रभावित किया;
\n
• स्लाइस में एलिमेंट की उपस्थिति कैसे जांचें (नए slices.Contains फंक्शन सहित);
\n
• मैप में खोज कैसे काम करती है (स्पॉयलर: यह सबसे तेज़ तरीका है);
\n
• strings.Contains के माध्यम से स्ट्रिंग में सबस्ट्रिंग खोज;
\n
• "पायथोनिक" शैली के लिए अपना सार्वभौमिक रैपर फंक्शन लिखेंगे;
\n
• दृष्टिकोणों के प्रदर्शन की तुलना करेंगे।
\n

Go "if x in" क्यों नहीं चाहता?

Go एक न्यूनतम भाषा है। इसके निर्माताओं (रॉब पाइक, केन थॉम्पसन, रॉब ग्रीज़मर) ने जानबूझकर सिंटैक्स को ओवरलोड करने से परहेज किया। in कीवर्ड जोड़ने के बजाय, उन्होंने स्पष्ट लूप और अंतर्निहित निर्माण का उपयोग करने का सुझाव दिया।

यह कोई कमी नहीं है, बल्कि एक विशेषता है: आप हमेशा देखते हैं कि वास्तव में क्या हो रहा है। उदाहरण के लिए, मैप के लिए सिंटैक्स value, ok := myMap[key] आपको न केवल उपस्थिति की जांच देता है, बल्कि मान भी देता है — यह केवल बूलियन True/False से अधिक शक्तिशाली है।

तरीका 1: स्लाइस में खोज (क्लासिक)

सबसे सामान्य परिदृश्य। मान लीजिए, आपके पास स्ट्रिंग्स का एक स्लाइस है, और आपको जांचना है कि उसमें "Go" है या नहीं।

Go 1.21 संस्करण से पहले, आपको मैन्युअल रूप से लूप लिखना पड़ता था:

package main\n\nimport "fmt"\n\nfunc contains(slice []string, target string) bool {\n    for _, v := range slice {\n        if v == target {\n            return true\n        }\n    }\n    return false\n}\n\nfunc main() {\n    languages := []string{"Python", "Java", "Go", "Rust"}\n    if contains(languages, "Go") {\n        fmt.Println("Go मिल गया!")\n    }\n}\n

यह कोड मुहावरेदार Go है। यह स्पष्ट, तेज़ और समझने योग्य है। छोटे स्लाइस (1000 एलिमेंट तक) के लिए, ऐसी रैखिक खोज बढ़िया काम करती है।

तरीका 1.1: slices.Contains का उपयोग करें (Go 1.21+)

Go 1.21 संस्करण (अगस्त 2023 में जारी) से शुरू करके, मानक लाइब्रेरी में तैयार Contains फंक्शन के साथ slices पैकेज जोड़ा गया। अब आपका कोड लगभग Python जितना ही संक्षिप्त हो जाता है:

package main\n\nimport (\n    "fmt"\n    "slices"\n)\n\nfunc main() {\n    languages := []string{"Python", "Java", "Go", "Rust"}\n    if slices.Contains(languages, "Go") {\n        fmt.Println("Go मिल गया! (slices.Contains के माध्यम से)")\n    }\n}\n

महत्वपूर्ण: slices.Contains एक जेनेरिक फंक्शन है। यह किसी भी प्रकार के साथ काम करता है जो == ऑपरेटर को सपोर्ट करता है (स्ट्रिंग्स, संख्याएं, बूलियन मान, अंदर स्लाइस/मैप के बिना स्ट्रक्चर)।

तरीका 2: मैप में खोज — प्रदर्शन का राजा

Python में, आप शब्दकोशों के लिए in का उपयोग करते हैं, और यह स्थिर समय O(1) है। Go में भी ऐसा ही है, लेकिन सिंटैक्स अलग है:

package main\n\nimport "fmt"\n\nfunc main() {\n    // मैप को सेट के रूप में बनाएं\n    fruits := map[string]bool{\n        "apple":  true,\n        "banana": true,\n        "cherry": true,\n    }\n\n    if fruits["banana"] {\n        fmt.Println("banana मौजूद है!")\n    }\n\n    // अधिक सही तरीका — ok के साथ जांच\n    if _, ok := fruits["orange"]; ok