Go: कार्यात्मक या OOP? प्रोग्रामिंग शैली चुनना

परिचय: Go की दुनिया में शाश्वत बहस

Go — एक भाषा जिसने पैटर्न तोड़ दिए। यह अनावश्यक जटिलता को माफ नहीं करती, लेकिन साथ ही डेवलपर को अविश्वसनीय स्वतंत्रता देती है। हर कोई जो Go में लिखना शुरू करता है (या Python या Java से स्विच करता है), देर-सबेर एक दीवार से टकराता है: "सही तरीका क्या है? Java की तरह क्लासेस और इनहेरिटेंस के साथ लिखें या Haskell की तरह साइड इफेक्ट के बिना फ़ंक्शन के साथ?"

स्पॉयलर: Go न तो पूरी तरह से ऑब्जेक्ट-ओरिएंटेड है और न ही पूरी तरह से कार्यात्मक भाषा। यह एक व्यावहारिक भाषा है। लेकिन इसका मतलब यह नहीं है कि आप दोनों प्रतिमानों का उपयोग नहीं कर सकते (और नहीं करना चाहिए)। इस लेख में, हम समझेंगे कि Go में कार्यात्मक और ऑब्जेक्ट-ओरिएंटेड दृष्टिकोण को कैसे संयोजित किया जाए ताकि आपका कोड पढ़ने योग्य, परीक्षण योग्य और तेज़ हो। हम व्याख्यान नहीं देंगे, बल्कि वास्तविक उदाहरणों और एंटी-पैटर्न को देखेंगे।

यदि आप Go की सर्वोत्तम प्रथाओं की तलाश कर रहे हैं और समझना चाहते हैं कि इस भाषा में स्वच्छ कोड कैसे लिखें — तो आप सही जगह पर हैं।

1. Go में ऑब्जेक्ट-ओरिएंटेड दृष्टिकोण: बिना क्लासेस के, लेकिन दिल से

कई लोग मानते हैं कि चूंकि Go में class नहीं है, इसलिए इसमें OOP नहीं है। यह एक मिथक है। Go में OOP दो स्तंभों पर आधारित है: स्ट्रक्चर (structs) और इंटरफ़ेस (interfaces)। इनहेरिटेंस नहीं है, लेकिन कम्पोज़ीशन है, जिसे भाषा के निर्माता अधिक लचीला मानते हैं।

स्ट्रक्चर और मेथड

आप किसी भी प्रकार के लिए मेथड परिभाषित कर सकते हैं। यही ऑब्जेक्ट-ओरिएंटेड कोड का आधार है।

package main\n\nimport "fmt"\n\n// इंटरफ़ेस (कॉन्ट्रैक्ट) परिभाषित करना\ntype Notifier interface {\n    Send(message string) error\n}\n\n// स्ट्रक्चर जो इंटरफ़ेस को लागू करता है\ntype EmailNotifier struct {\n    Email string\n}\n\n// EmailNotifier के लिए मेथड\nfunc (e EmailNotifier) Send(message string) error {\n    fmt.Printf("%s पर ईमेल भेज रहे हैं: %s\\n", e.Email, message)\n    return nil\n}\n\n// एक और स्ट्रक्चर\ntype SMSNotifier struct {\n    Phone string\n}\n\nfunc (s SMSNotifier) Send(message string) error {\n    fmt.Printf("%s पर SMS भेज रहे हैं: %s\\n", s.Phone, message)\n    return nil\n}\n\n// फ़ंक्शन जो किसी भी Notifier को स्वीकार करता है (पॉलीमॉर्फ़िज़्म)\nfunc AlertAll(notifiers []Notifier, msg string) {\n    for _, n := range notifiers {\n        n.Send(msg)\n    }\n}\n\nfunc main() {\n    notifiers := []Notifier{\n        EmailNotifier{Email: "user@example.com"},\n        SMSNotifier{Phone: "+1234567890"},\n    }\n    AlertAll(notifiers, "सर्वर डाउन हो गया!")\n}

Go में OOP के लाभ:

\n
• इंटरफ़ेस के माध्यम से पॉलीमॉर्फ़िज़्म। आप एक बार AlertAll फ़ंक्शन लिखते हैं, और यह किसी भी प्रकार के साथ काम करता है जो Notifier को लागू करता है। यह कमजोर युग्मन है।
\n
• अवस्था (State)। स्ट्रक्चर डेटा मॉडल (User, Order, Config) के लिए आदर्श हैं।
\n
• एनकैप्सुलेशन। छोटे अक्षरों वाले फ़ील्ड प्राइवेट हैं, बड़े अक्षरों वाले पब्लिक हैं। सरल और प्रभावी।
\n

नुकसान:

\n
• "Java-शैली" में फिसलना आसान है: गहरी पदानुक्रम बनाना, हालाँकि Go उनका समर्थन नहीं करता।
\n
• परिवर्तनशीलता (अवस्था बदलना) परीक्षण और डिबगिंग को जटिल बनाती है।
\n

2. Go में कार्यात्मक प्रोग्रामिंग: गति के लिए शुद्धता

Go में कार्यात्मक शैली लैम्ब्डा कैलकुलस नहीं है, बल्कि सिद्धांतों का एक सेट है: न्यूनतम साइड इफेक्ट, अपरिवर्तनीयता, फ़ंक्शन को तर्क के रूप में उपयोग करना। जेनेरिक्स (Go 1.18+) के आगमन के साथ, यह शैली और अधिक शक्तिशाली हो गई है।

शुद्ध फ़ंक्शन और अपरिवर्तनीयता

कार्यात्मकता का मुख्य नियम: फ़ंक्शन डेटा प्राप्त करता है, नया डेटा लौटाता है, लेकिन बाहर कुछ भी नहीं बदलता।

package main\n\nimport "fmt"\n\n// बुरा: इनकमिंग स्लाइस को म्यूट करना (साइड इफेक्ट)\nfunc BadAddPrefix(users []string, prefix string) {\n    for i := range users {\n        users[i] = prefix + users[i]\n    }\n}\n\n// अच्छा: नया स्लाइस लौटाना (शुद्ध फ़ंक्शन)\