"मुझे अभी भी शुरुआती दिन याद हैं जब मैं कोड के साथ कुश्ती लड़ रहा था।

बुनियादी सामान? मैं वहां पहुंच रहा था. लेकिन फिर संरचनाएँ आईं, और सब कुछ धुंधला सा महसूस हुआ। मैं चीज़ें तोड़ता रहा और मेरा कोड गड़बड़ हो गया। मैं क्या गलत कर रहा था?
जब तक मैं बैठ नहीं गया, गो संरचनाओं की मूल बातें नहीं सीखीं, और उनका प्रभावी ढंग से उपयोग करना शुरू नहीं किया, तब तक चीजें अंततः सफल रहीं। वह निर्णायक मोड़ था. अचानक, कोड अधिक व्यवस्थित, कुशल और साफ़ हो गया। इसने मेरे प्रोग्रामिंग करने के तरीके को बदल दिया और मुझे कोडिंग का इतना आनंद आने लगा जितना पहले कभी नहीं मिला था।"
यदि आप भी उसी नाव में हैं - सोच रहे हैं कि संरचनाएँ इतनी शक्तिशाली क्यों हैं - तो यह पोस्ट आपके लिए है। आइए मैं आपको संरचनाओं के रहस्यों को उजागर करने की यात्रा पर ले चलता हूं और आपको दिखाता हूं कि वे आपके कोडिंग गेम को कैसे बदल सकते हैं!

एक संरचना क्या है?
गो में, एक संरचना एक ब्लूप्रिंट की तरह होती है जो आपको विभिन्न प्रकार के डेटा को एक साथ बंडल करने की अनुमति देती है। इसे व्यक्ति, कार या पुस्तक जैसी जटिल इकाइयों के मॉडलिंग के लिए एक कस्टम डेटा संरचना के रूप में सोचें।
उदाहरण के लिए, एक व्यक्ति संरचना किसी व्यक्ति का नाम, आयु और लिंग जैसे फ़ील्ड रख सकती है - जो संबंधित जानकारी को समूहीकृत करने के लिए बिल्कुल उपयुक्त है।
संरचनाओं का उपयोग क्यों करें?
संरचनाएं आपको संबंधित डेटा को एक साथ व्यवस्थित और बंडल करने में मदद करती हैं, जिससे जटिल डेटा मॉडल को प्रबंधित करना आसान हो जाता है। चाहे आप एक ऐप बना रहे हों जो उपयोगकर्ताओं, उत्पादों या इन्वेंट्री को ट्रैक करता है, संरचनाएं आपको विभिन्न प्रकार के डेटा को समूहीकृत करने की अनुमति देती हैं, ठीक उसी तरह जैसे किसी पते में एक सड़क, शहर और ज़िप कोड होता है।
एक संरचना की घोषणा: मूल बातें
वाक्यविन्यास अत्यंत सरल है. आप कीवर्ड प्रकार के साथ एक संरचना को परिभाषित करते हैं, उसके बाद संरचना नाम, और फिर घुंघराले ब्रेसिज़ के अंदर फ़ील्ड:

type Person struct {
    Name   string
    Age    int
    Gender string
}

अब आपके पास एक व्यक्ति संरचना है जिसमें तीन फ़ील्ड हैं: नाम (स्ट्रिंग), आयु (इंट), और लिंग (स्ट्रिंग)।

संरचना फ़ील्ड तक पहुंच और संशोधन

किसी संरचना के फ़ील्ड तक पहुंचने के लिए, आप बस डॉट (.) ऑपरेटर का उपयोग करते हैं:

fmt.Println("Name:", person.Name)
fmt.Println("Age:", person.Age)
fmt.Println("Gender:", person.Gender)

फ़ील्ड बदल रहा है? आसान! आप मानों को वैसे ही संशोधित कर सकते हैं जैसे आप किसी अन्य वेरिएबल के साथ करेंगे:

person.Age = 26
fmt.Println("Updated Age:", person.Age)

कोडर्स structs पर भरोसा क्यों नहीं करते?
क्योंकि वे अपने "क्षेत्रों" से निपटना नहीं चाहते हैं

संरचना विधियां: व्यवहार जोड़ना

यहां चीजें और भी दिलचस्प हो जाती हैं। आप संरचनाओं को व्यवहार देने के लिए उनमें विधियाँ संलग्न कर सकते हैं। यह किसी संरचना को कार्य करने की क्षमता देने जैसा है!

आइए व्यक्ति संरचना के लिए अभिवादन विधि को परिभाषित करें:

func (p Person) Greet() string {
    return "Hello, my name is "   p.Name
}

अब आप उस व्यक्ति से आपका अभिवादन करवा सकते हैं:

fmt.Println(person.Greet())

नेस्टेड संरचनाओं के साथ संरचनाएं: चीजों को जटिल, फिर भी सरल बनाना

गो स्ट्रक्चर अपने अंदर अन्य स्ट्रक्चर रख सकते हैं, जो तब उपयोगी होता है जब आप अधिक जटिल डेटा मॉडल करना चाहते हैं। एक छात्र संरचना की कल्पना करें जिसमें संपूर्ण प्रोफ़ाइल के लिए एक पता संरचना शामिल है:

type Address struct {
    City  string
    State string
}

type Student struct {
    Name    string
    Age     int
    Address Address
}

अब आप एक छात्र बना सकते हैं और इस तरह नेस्टेड फ़ील्ड तक पहुंच सकते हैं:

student := Student{
    Name: "Fred Gitonga",
    Age:  21,
    Address: Address{
        City:  "Kisumu",
        State: "Mamboleo",
    },
}

fmt.Println(student.Name, "lives in", student.Address.City)

"प्रोग्राम लोगों के पढ़ने के लिए और केवल संयोगवश मशीनों द्वारा निष्पादित करने के लिए लिखे जाने चाहिए।" - हेरोल्ड एबेलसन

संरचनाओं के साथ सामान्य गलतियाँ

इससे पहले कि आप संरचनाओं के साथ बेतहाशा भाग जाएं, इन सामान्य नुकसानों से सावधान रहें:

1. अप्रारंभिक फ़ील्ड्स: यदि आप फ़ील्ड्स को प्रारंभ नहीं करते हैं तो गो स्वचालित रूप से डिफ़ॉल्ट शून्य मान निर्दिष्ट करता है (जैसे कि ints के लिए 0 या स्ट्रिंग्स के लिए "")।
2. आवश्यकता न होने पर पॉइंटर्स का उपयोग करना: छोटी संरचनाओं के लिए, उन्हें संदर्भ के बजाय मूल्य के आधार पर पारित करना अक्सर अधिक कुशल होता है।

अभ्यास परिपूर्ण बनाता है!

1. आसान: शीर्षक, लेखक और पेज फ़ील्ड के साथ एक पुस्तक संरचना बनाएं। पुस्तक की जानकारी प्रदर्शित करने की एक विधि लिखें।
2. इंटरमीडिएट: एक लाइब्रेरी संरचना बनाएं जिसमें एकाधिक पुस्तक संरचनाएं हों। किसी पुस्तक को जोड़ने और लाइब्रेरी में सभी पुस्तकों को सूचीबद्ध करने की विधियाँ लिखें।
3. उन्नत: एक वाहन संरचना बनाएं और बेड़े संरचना का उपयोग करके वाहनों के एक बेड़े का प्रबंधन करें, जिसमें वर्ष के अनुसार वाहनों को जोड़ना, हटाना और खोजना शामिल है।

निष्कर्ष: मुख्य निष्कर्ष

1. गो में संबंधित डेटा को समूहीकृत करने के लिए संरचनाएं आवश्यक हैं।
2. आप विधियों और यहां तक ​​कि नेस्टेड संरचनाओं के साथ संरचनाओं को बढ़ा सकते हैं।
3. जब आपको किसी फ़ंक्शन के अंदर मूल संरचना को संशोधित करने की आवश्यकता हो तो पॉइंटर्स का उपयोग करें।

अगर गो स्ट्रक्चर्स मेरे लिए कोडिंग को आसान बना सकते हैं, तो वे निश्चित रूप से आपके लिए भी ऐसा ही करेंगे। हैप्पी कोडिंग!