गोलांग मैप सीखना

1 मानचित्र का परिचय

Go भाषा में, मानचित्र एक विशेष डेटा प्रकार है जो विभिन्न प्रकारों के कुंजी-मान (key-value) जोड़ों को संग्रहित कर सकता है। यह पायथन में शब्दकोश या जावा में HashMap के तरह है। Go में, एक मानचित्र एक हैश तालिका का उपयोग करके लागू करने वाला एक निर्मित प्रकार है, जिससे इसे तेज डेटा खोज, अपडेट और हटाने की विशेषताएँ मिलती हैं।

विशेषताएँ

• संदर्भ प्रकार: मानचित्र एक संदर्भ प्रकार है, जिसका मतलब है कि निर्माण के बाद, यह वास्तव में मूल डेटा संरचना के एक प्वाइंटर प्राप्त करता है।
• गतिशील विस्तार: लेन में, मानचित्र का अंतरिक्ष स्थिर नहीं है और डेटा बढ़ते समय डाइनैमिक रूप से विस्तारित होता है।
• कुंजीयता: मानचित्र में प्रत्येक कुंजी अद्वितीय है, और अगर समान कुंजी का उपयोग करके एक मौलिक स्तर स्थान में एक मूल्य संग्रहीत किया जाता है, तो नया मूल्य मौजूदा को ओवरराइड कर देगा।
• अव्यवस्थित संग्रह: मानचित्र में तत्व अव्यवस्थित होते हैं, इसलिए कुंजी-मान जोड़ों का क्रम, मानचित्र को प्रवेश करने के प्रत्येक बार अलग हो सकता है।

उपयोग मामले

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

2 मानचित्र बनाना

2.1 make फ़ंक्शन का उपयोग करके बनाना

मानचित्र बनाने का सबसे सामान्य तरीका make फ़ंक्शन का उपयोग करके होता है, निम्नलिखित सिंटैक्स के साथ:

make(map[keyType]valueType)

यहां, keyType कुंजी का प्रकार है, और valueType मूल्य का प्रकार है। यहाँ एक विशिष्ट उपयोग उदाहरण है:

// एक मानचित्र बनाएँ जिसमें एक स्ट्रिंग कुंजी प्रकार और एक पूर्णांक मान प्रकार है
m := make(map[string]int)

इस उदाहरण में, हमने एक खाली मानचित्र बनाया है जिसका उपयोग स्ट्रिंग कुंजियों और पूर्णांक मूल्यों को संग्रहित करने के लिए किया जाएगा।

2.2 शब्दीय सिंटैक्स का उपयोग करके बनाना

make का उपयोग करने के अलावा, हम संक्षेप वाक्य विधि का उपयोग करके एक मानचित्र बना और प्रारंभ कर सकते हैं, जिसमें समय के साथ कुंजी-मान जोड़े घोषित किए गए होते हैं:

m := map[string]int{
    "सेब": 5,
    "नाशपाती": 6,
    "केला": 3,
}

इससे न केवल एक मानचित्र बनता है, बल्कि इसके लिए तीन कुंजी-मान जोड़े सेट भी किए जाते हैं।

2.3 मानचित्र प्रारंभ करने के लिए विचार

मानचित्र का उपयोग करते समय, यह महत्वपूर्ण है कि एक अप्रारंभित मानचित्र का शून्य मूल्य nil होता है, और आप इस समय सीधे कुंजी-मान जोड़ों को उसमें संग्रहित नहीं कर सकते, या फिर यह एक रनटाइम पैनिक को कारण बना देगा। आपको किसी भी कार्रवाई से पहले इसे प्रारंभ करने के लिए make का उपयोग करना चाहिए:

var m map[string]int
if m == nil {
    m = make(map[string]int)
}
// m का उपयोग करना अब सुरक्षित है

दस्तावेजीय के लिए यह भी महत्वपूर्ण है कि कुंजी के अस्तित्व की जाँच के लिए विशेष संकेतक है:

value, ok := m["कुंजी"]
if !ok {
    // "कुंजी" मानचित्र में नहीं है
}

यहां, मूल्य दिए गए कुंजी के साथ जुड़ा मूल्य है, और ok एक बूलियन मान है जो सही है अगर कुंजी मानचित्र में मौजूद है और यदि यह मौजूद नहीं है तो गलत।

3 मानचित्र तक पहुंचना और संशोधन

3.1 तत्वों तक पहुंचना

Go भाषा में, आप मानचित्र में एक कुंजी के अनुसार एक मान का उपयोग करके मानचित्र में अनुसारित मूल्य तक पहुंच सकते हैं। अगर कुंजी मानचित्र में मौजूद है, तो आपको संबंधित मूल्य मिलेगा। वास्तव में, अगर कुंजी मौजूद नहीं है, तो आपको मूल्य प्रकार की शून्य मान मिलेगी। उदाहरण के लिए, पूर्णांक संग्रहित करने वाले मानचित्र में, कुंजी मौजूद नहीं होने पर, यह 0 लौटाएगा।

func main() {
    // एक मानचित्र परिभाषित करें
    scores := map[string]int{
        "ऐलिस": 92,
        "बॉब": 85,
    }

    // मौजूदा कुंजी तक पहुंचना
    aliceScore := scores["ऐलिस"]
    fmt.Println("ऐलिस का स्कोर:", aliceScore) // आउटपुट: ऐलिस का स्कोर: 92

    // मौजूद न कुंजी तक पहुंचना
    missingScore := scores["चार्ली"]
    fmt.Println("चार्ली का स्कोर:", missingScore) // आउटपुट: चार्ली का स्कोर: 0
}

ध्यान दें कि यहां, कुंजी "चार्ली" मौजूद न होने के बावजूद, यह त्रुटि का कारण नहीं बनाता है, बल्कि बजाय इसके इसमें पूर्णांक शून्य मान, 0 लौटाएगा।

3.2 कुंजी की मौजूदगी की जांच

कभी-कभी, हमें सिर्फ यह जानना होता है कि क्या किसी मानचित्र में कोई कुंजी मौजूद है, बिना उसके संबंधित मान की चिंता किए। इस मामले में, आप मानचित्र पहुंच का दूसरा रिटर्न मूल्य प्रयोग कर सकते हैं। यह बूलियन रिटर्न मूल्य हमें बताएगा कि क्या कुंजी मानचित्र में मौजूद है या नहीं।

func main() {
    scores := map[string]int{
        "Alice": 92,
        "Bob": 85,
    }

    // "Bob" कुंजी की मौजूदगी की जांच
    score, exists := scores["Bob"]
    if exists {
        fmt.Println("बॉब का स्कोर:", score)
    } else {
        fmt.Println("बॉब का स्कोर नहीं मिला।")
    }

    // "Charlie" कुंजी की मौजूदगी की जांच
    _, exists = scores["Charlie"]
    if exists {
        fmt.Println("चार्ली का स्कोर मिला।")
    } else {
        fmt.Println("चार्ली का स्कोर नहीं मिला।")
    }
}

इस उदाहरण में, हम बूलियन मूल्य की जांच करने के लिए एक यदि बयान का उपयोग करते हैं ताकि हम कुंजी की मौजूदगी का निर्धारण कर सकें।

3.3 तत्त्व जोड़ना और अपडेट करना

मानचित्र में नए तत्त्व जोड़ना और मौजूदा तत्त्वों को अपडेट करने के लिए दोनों ही संदर्भ का उपयोग किया जाता है। अगर कुंजी पहले से मौजूद है, तो मौजूदा मान को नए मान से बदल दिया जाएगा। अगर कुंजी मौजूद नहीं है, तो एक नया कुंजी-मान जोड़ा जाएगा।

func main() {
    // एक खाली मानचित्र को परिभाषित करें
    scores := make(map[string]int)

    // तत्त्व जोड़ना
    scores["Alice"] = 92
    scores["Bob"] = 85

    // तत्त्वों को अपडेट करना
    scores["Alice"] = 96  // मौजूदा कुंजी को अपडेट करना
    
    // मानचित्र प्रिंट करें
    fmt.Println(scores)   // आउटपुट: map[Alice:96 Bob:85]
}

तत्त्व जोड़ने और अपडेट करने के कार्य संक्षेपण और सरल आसानी से संपन्न किए जा सकते हैं।

3.4 तत्त्वों को हटाना

मानचित्र से तत्त्वों को हटाना निर्मित delete फ़ंक्शन का उपयोग करके किया जा सकता है। निम्नलिखित उदाहरण में हटाने का कार्य विवरणित करता है:

func main() {
    scores := map[string]int{
        "Alice": 92,
        "Bob": 85,
        "Charlie": 78,
    }

    // एक तत्त्व हटाएँ
    delete(scores, "Charlie")

    // मानचित्र प्रिंट करें ताकि चार्ली हटा दिया गया है
    fmt.Println(scores)  // आउटपुट: map[Alice:92 Bob:85]
}

delete फ़ंक्शन को दो पैरामीटर लेते हुए, पहले पैरामीटर के रूप में मानचित्र और दूसरे पैरामीटर के रूप में हटाने वाली कुंजी लेता है। अगर कुंजी मानचित्र में मौजूद नहीं है, तो delete फ़ंक्शन का कोई असर नहीं होगा और यह कोई त्रुटि नहीं फेंकेगा।

4 मानचित्र का अध्ययन

Go भाषा में, आप मानचित्र डेटा संरचना को अध्ययन करने और प्रत्येक कुंजी-मान जोड़ का उपयोग करने के लिए for range बयान का उपयोग कर सकते हैं। इस प्रकार के दोहरावली संचालन कार्य को मानचित्र डेटा संरचना द्वारा समर्थित मौलिक कार्य करने वाली आवश्यकता को पूरा करता है।

4.1 for range का उपयोग करके मानचित्र पर चक्र चालाना

for range बयान को मानचित्र पर सीधे उपयोग किया जा सकता है ताकि मानचित्र में प्रत्येक कुंजी-मान जोड़ प्राप्त किया जा सके। नीचे एक मानचित्र पर for range का उपयोग करने का एक मूल उदाहरण है:

package main

import "fmt"

func main() {
    myMap := map[string]int{"Alice": 23, "Bob": 25, "Charlie": 28}

    for key, value := range myMap {
        fmt.Printf("कुंजी: %s, मान: %d\n", key, value)
    }
}

इस उदाहरण में, key चर वेरिएबल को वर्तमान चक्रण की कुंजी, और value वेरिएबल को उस कुंजी के साथ संबद्ध मान के रूप में सौंपा जाता है।

4.2 चक्रण क्रम के बारे में विचार

मानचित्र पर चक्रण करते समय यह महत्वपूर्ण है कि चक्रण का क्रम प्रत्येक बार समान न हो, भले ही मानचित्र की सामग्री में कोई परिवर्तन न हो। यह इसलिए है क्योंकि Go में मानचित्र पर चक्रण की प्रक्रिया यादृच्छिक बनाई गई है, ताकि कोड को किसी विशिष्ट चक्रण क्रम पर आश्रित करने से रोका जा सके, और इस प्रकार से कोड की सुरक्षा बढ़ाई जा सके।

उदाहरण के लिए, निम्नलिखित कोड को दो बार लगातार चलाने पर भिन्न आउटपुट मिल सकता है:

package main

import "fmt"

func main() {
    myMap := map[string]int{"Alice": 23, "Bob": 25, "Charlie": 28}

    fmt.Println("पहला चक्रण:")
    for key, value := range myMap {
        fmt.Printf("कुंजी: %s, मान: %d\n", key, value)
    }

    fmt.Println("\nदूसरा चक्रण:")
    for key, value := range myMap {
        fmt.Printf("कुंजी: %s, मान: %d\n", key, value)
    }
}

मैप्स पर 5 अग्रणी विषय

अगले, हम मैप्स से संबंधित कई उन्नत विषयों पर विचार करेंगे, जो आपको मैप्स को बेहतर ढंग से समझने और उपयोग करने में मदद कर सकते हैं।

5.1 मैप्स की यादास्त और प्रदर्शन विशेषताएँ

Go भाषा में, मैप्स एक बहुत ही लचीला और शक्तिशाली डेटा प्रकार हैं, लेकिन उनकी गतिविधि के कारण, उनके मेमोरी उपयोग और प्रदर्शन में विशेष विशेषताएँ भी होती हैं। उदाहरण के लिए, एक मैप्स का आकार नामकरणीय रूप से बढ़ सकता है, और जब संग्रहित तत्वों की संख्या मौजूदा क्षमता को पार कर जाती है, तो मैप्स स्वचालित रूप से एक बड़े संग्रहण स्थान को विस्तारित करने के लिए पुनर्आवंटन करेंगे।

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

myMap := make(map[string]int, 100)

इससे दौरान समय में मैप्स के गतिविधि के अधिभार को कम किया जा सकता है।

5.2 मैप्स की संदर्भ प्रकार विशेषताएँ

मैप्स संदर्भ प्रकार होते हैं, जिसका मतलब है कि जब आप किसी अन्य चर में मैप को सौंपते हैं, तो नया चर मूल मैप के समान डेटा संरचना को संदर्भित करेगा। यह यह भी मतलब है कि यदि आप नए चर के माध्यम से मैप में परिवर्तन करते हैं, तो ये परिवर्तन मूल मैप चर में भी प्रतिबिम्बित होंगे।

यहां एक उदाहरण है:

package main

import "fmt"

func main() {
    originalMap := map[string]int{"Alice": 23, "Bob": 25}
    newMap := originalMap

    newMap["Charlie"] = 28

    fmt.Println(originalMap) // आउटपुट में नए जोड़े गए "Charlie": 28 कुंजी-मूल्य जोड़ा गया होगा
}

एक फ़ंक्शन कॉल में मैप को पैरामीटर के रूप में पार करते समय, संदर्भ प्रकार के व्यवहार को ध्यान में रखना भी महत्वपूर्ण है। इस समय, जो पार किया जाता है, वह मैप का संदर्भ है, न कि नकल।

5.3 समवर्थन सुरक्षा और sync.Map

मैप का उपयोग एक समवृत्ति के वातावरण में करते समय, समवर्थन सुरक्षा मुद्दों पर विशेष ध्यान दिया जाना चाहिए। एक समवृत्ति स्थिति में, गो भाषा में मैप प्रकार यदि उचित समवर्थन की संचालन नहीं किया गया तो रेस स्थितियों का कारण बन सकता है।

Go मानक पुस्तकालय sync.Map प्रकार प्रदान करती है, जो समवर्थन वातावरण के लिए डिज़ाइन किया सुरक्षित मैप है। इस प्रकार नियमक विधि जैसे Load, Store, LoadOrStore, Delete, और Range को मैप पर ऑपरेट करने के लिए उपलब्ध कराता है।

नीचे sync.Map का उपयोग करने का एक उदाहरण है:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mySyncMap sync.Map

    // कुंजी-मूल्य जोड़ना
    mySyncMap.Store("Alice", 23)
    mySyncMap.Store("Bob", 25)

    // कुंजी-मूल्य पैर रिट्राइभ और प्रिंट करना
    if value, ok := mySyncMap.Load("Alice"); ok {
        fmt.Printf("कुंजी: Alice, मूल्य: %d\n", value)
    }

    // Range मेथड का उपयोग sync.Map के माध्यम से iterate करने के लिए
    mySyncMap.Range(func(key, value interface{}) bool {
        fmt.Printf("कुंजी: %v, मूल्य: %v\n", key, value)
        return true // iterate जारी रखें
    })
}

साधारण मैप की बजाय sync.Map का उपयोग एक समवर्थन वातावरण में मैप को संशोधित करते समय रेस स्थिति मुद्दों से बच सकता है, जिससे धागा सुरक्षा सुनिश्चित होती है।