Go में डिज़ाइन पैटर्न उदाहरणों के साथ: A से Z तक

Go में डिज़ाइन पैटर्न उदाहरणों के साथ: A से Z तक

डिज़ाइन पैटर्न (Design Patterns) समय-परीक्षित आर्किटेक्चरल समाधान हैं जो Go डेवलपर्स को लचीला, स्केलेबल और रखरखाव योग्य कोड बनाने में मदद करते हैं। पारंपरिक OOP भाषाओं के विपरीत, Go इंटरफेस, कंपोज़िशन और गोरूटीन के माध्यम से पैटर्न को लागू करने का अपना अनूठा तरीका प्रदान करता है। इस लेख में, हम विशिष्ट कोड उदाहरणों के साथ Go में मुख्य डिज़ाइन पैटर्न पर चर्चा करेंगे।

1. क्रिएशनल पैटर्न (Creational Patterns)

क्रिएशनल पैटर्न ऑब्जेक्ट बनाने के लिए जिम्मेदार होते हैं, जो सिस्टम को उनके निर्माण के तरीके से स्वतंत्र बनाते हैं।

1.1. सिंगलटन (Singleton)

सिंगलटन यह सुनिश्चित करता है कि क्लास का केवल एक इंस्टेंस हो। Go में, इसे थ्रेड-सुरक्षा के लिए अक्सर sync.Once के माध्यम से कार्यान्वित किया जाता है।

package main\n\nimport (\n    "fmt"\n    "sync"\n)\n\ntype Database struct {\n    connection string\n}\n\nvar (\n    instance *Database\n    once     sync.Once\n)\n\nfunc GetDatabaseInstance() *Database {\n    once.Do(func() {\n        instance = &Database{connection: "postgres://localhost:5432/mydb"}\n        fmt.Println("डेटाबेस के लिए एकमात्र कनेक्शन बनाया गया")\n    })\n    return instance\n}\n\nfunc main() {\n    db1 := GetDatabaseInstance()\n    db2 := GetDatabaseInstance()\n    fmt.Println(db1 == db2) // true\n}

1.2. फैक्ट्री मेथड (Factory Method)

फैक्ट्री ऑब्जेक्ट निर्माण को उपवर्गों को सौंपती है। Go में, यह इंटरफेस का उपयोग करके किया जाता है।

package main\n\nimport "fmt"\n\n// उत्पाद इंटरफ़ेस\ntype Transport interface {\n    Deliver() string\n}\n\n// विशिष्ट उत्पाद\ntype Truck struct{}\nfunc (t Truck) Deliver() string { return "जमीन के रास्ते डिलीवरी" }\n\ntype Ship struct{}\nfunc (s Ship) Deliver() string { return "समुद्र के रास्ते डिलीवरी" }\n\n// फैक्ट्री\ntype LogisticsFactory interface {\n    CreateTransport() Transport\n}\n\ntype RoadLogistics struct{}\nfunc (r RoadLogistics) CreateTransport() Transport { return Truck{} }\n\ntype SeaLogistics struct{}\nfunc (s SeaLogistics) CreateTransport() Transport { return Ship{} }\n\nfunc main() {\n    var factory LogisticsFactory = RoadLogistics{}\n    transport := factory.CreateTransport()\n    fmt.Println(transport.Deliver()) // जमीन के रास्ते डिलीवरी\n}

2. स्ट्रक्चरल पैटर्न (Structural Patterns)

स्ट्रक्चरल पैटर्न क्लासेस और ऑब्जेक्ट्स को बड़ी संरचनाओं में व्यवस्थित करने में मदद करते हैं।

2.1. एडेप्टर (Adapter)

एडेप्टर असंगत इंटरफेस वाले ऑब्जेक्ट्स को एक साथ काम करने की अनुमति देता है। Go में, इसे रैपर के माध्यम से हल किया जाता है।

package main\n\nimport "fmt"\n\n// पुराना इंटरफ़ेस\ntype OldPrinter interface {\n    PrintOld(data string)\n}\n\ntype LegacyPrinter struct{}\nfunc (l LegacyPrinter) PrintOld(data string) {\n    fmt.Println("Legacy:", data)\n}\n\n// नया इंटरफ़ेस\ntype NewPrinter interface {\n    PrintNew(data string)\n}\n\n// एडेप्टर\ntype PrinterAdapter struct {\n    OldPrinter OldPrinter\n}\n\nfunc (a PrinterAdapter) PrintNew(data string) {\n    a.OldPrinter.PrintOld(data)\n}\n\nfunc main() {\n    legacy := LegacyPrinter{}\n    adapter := PrinterAdapter{OldPrinter: legacy}\n    adapter.PrintNew("Hello, Go!") // Legacy: Hello, Go!\n}

2.2. कम्पोज़िट (Composite)

कम्पोज़िट ऑब्जेक्ट्स के समूहों को एकल ऑब्जेक्ट के रूप में संसाधित करने की अनुमति देता है। यह ट्री-जैसी संरचनाओं के लिए आदर्श है।

package main\n\nimport "fmt"\n\n// घटक इंटरफ़ेस\ntype Graphic interface {\n    Draw() string\n}\n\n// लीफ तत्व\ntype Circle struct{}\nfunc (c Circle) Draw() string { return "वृत्त बनाएं" }\n\n// कंटेनर\ntype CompoundGraphic struct {\n    children []Graphic\n}\n\nfunc (cg *CompoundGraphic) Add(g Graphic) {\n    cg.children = append(cg.children, g)\n}\n\nfunc (cg *CompoundGraphic) Draw() string {\n    result := "सम्मिश्र आकृति:\\n"\n    for _, child := range cg.children {\n        result += "  - " + c