पहचान

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

मानचित्र घोषणा और आरंभीकरण

मानचित्र घोषित करने के लिए यह मानचित्र [कुंजी] मान के साथ किया जाता है, जहां कुंजी वह प्रकार होगी जो हम चाहते हैं कि हमारी कुंजी हो (यह एक तुलनीय प्रकार का होना चाहिए https://go.dev/ref/spec#Comparison_operator ) और मान वह प्रकार होगा जिसे हम चाहते हैं कि मानचित्र प्रत्येक कुंजी में संग्रहीत हो, चाहे वह किसी भी प्रकार का हो, एक इंट से एक संरचना तक, या कोई अन्य मानचित्र, जो भी हम चाहते हैं।

स्लाइस की तरह, मानचित्र भी संदर्भित प्रकार हैं, जिसका अर्थ है कि मानचित्र का शून्य मान शून्य होगा।
ऐसा इसलिए होता है क्योंकि इसके नीचे एक हैश तालिका होती है जो कुंजियों और मूल्यों को संग्रहीत करती है, और वे बस उनका एक लिफाफा, अमूर्त होते हैं।

यदि हम इसे इस प्रकार घोषित करते हैं:

var m map[int]int

इसका मूल्य शून्य होगा।

यदि हम चाहते हैं कि इसका मान शून्य हो, तो हम घोषणा का उपयोग कर सकते हैं:

m := map[int]int{}

और हम मेक फ़ंक्शन का उपयोग करके इसे स्लाइस की तरह ही इनिशियलाइज़ भी कर सकते हैं।

m := make(map[string]string)

ऐसा करने से इसके लिए उपयुक्त मेमोरी पूल के साथ एक हैश मैप प्रारंभ हो जाएगा, इस प्रकार एक मैप वापस आ जाएगा जो उस डेटा संरचना को इंगित करता है।

मानचित्र से मान जोड़ना और पढ़ना

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

ages := make(map[string]int)

ages["John"] = 33
ages["Charly"] = 27
ages["Jenny"] = 45
ages["Lisa"] = 19

यदि हम मानचित्र घोषित करते समय इसमें मान जोड़ना चाहते हैं, तो हम संक्षिप्त घोषणा का उपयोग कर सकते हैं और यह सब एक ही चरण में कर सकते हैं:

ages := map[string]int{"John": 33, "Charly": 27, "Jenny": 45, "Lisa": 19}

मानों को पढ़ने के लिए, हमें बस अपने मानचित्र की कुंजी को इंगित करना होगा और यह उस मान को वापस कर देगा। उदाहरण के लिए, लिसा की उम्र जानने के लिए, हम यह कर सकते हैं:

fmt.Println(ages["Lisa"]) // 19

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

यह जांचने के लिए कि मानचित्र में कोई तत्व मौजूद है या नहीं, हम जांच सकते हैं कि क्या प्रकार डिफ़ॉल्ट है, लेकिन यह बहुत विश्वसनीय नहीं है, क्योंकि शायद यह मौजूद है लेकिन इसका मान एक खाली स्ट्रिंग है या इंट के मामले में 0 है , जो इसके शून्य मान से मेल खाएगा, इसलिए गो हमें निम्नलिखित में मदद करता है:

val, ok := ages["Randy"]

यदि हम मानचित्र को दो मानों के बराबर करते हैं, तो पहला कुंजी के माध्यम से एक्सेस किए गए तत्व का मान होगा, इस मामले में "रैंडी" जो अस्तित्व में नहीं है, और दूसरा एक बूलियन होगा, जो इंगित करेगा कि क्या यह मौजूद है या नहीं.

यदि हमें मूल्य में कोई दिलचस्पी नहीं है और हम केवल कुंजी के अस्तित्व की जांच करना चाहते हैं, तो हम मूल्य को अनदेखा करने के लिए _ का उपयोग इस प्रकार कर सकते हैं:

_, ok := ages["Randy"]

सरणी और स्लाइस की तरह, हम यह पता लगाने के लिए लेन फ़ंक्शन का उपयोग कर सकते हैं कि मानचित्र में कितने तत्व हैं।

fmt.Println(len(ages)) // 4

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

यदि हम पहले की ओर इशारा करते हुए दूसरा नक्शा घोषित करते हैं, यदि हम दूसरे के मूल्य को संशोधित करते हैं, क्योंकि यह एक संदर्भित प्रकार है, तो हम पहले के मूल्य को संशोधित करेंगे, क्योंकि दोनों नीचे एक ही हैश तालिका साझा करते हैं।
&&&]

ages := map[string]int{"John": 33, "Charly": 27, "Jenny": 45, "Lisa": 19}
agesNew := ages
agesNew["Bryan"] = 77
fmt.Println(agesNew) // map[Bryan:77 Charly:27 Jenny:45 John:33 Lisa:19]
fmt.Println(ages) // map[Bryan:77 Charly:27 Jenny:45 John:33 Lisa:19]

मानचित्र से मान हटाना

मैप से तत्वों को हटाने के लिए, गो हमें निम्नलिखित हस्ताक्षर डिलीट (एम मैप[टाइप] टाइप1, कुंजी प्रकार) के साथ एक डिलीट फ़ंक्शन प्रदान करता है जो एक मैप और हटाए जाने वाली कुंजी प्राप्त करता है।
पिछले मामले में, यदि हम "लिसा" को ख़त्म करना चाहते तो हम यह करते:

delete(ages, "Lisa")

मानचित्रों के माध्यम से लूपिंग

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

for key, value := range ages {
    fmt.Printf("%s: %d\n", key, value)
}

// Output:
// Jenny: 45
// Lisa: 19
// John: 33
// Charly: 27

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

for _, value := range ages {
    fmt.Println(value)
}

// Output:
// 19
// 33
// 27
// 45

और यदि हमारी रुचि केवल कुंजी है, तो हम इसे प्राप्त करने के लिए एक एकल चर की सीमा निर्दिष्ट कर सकते हैं:

for key := range ages {
    fmt.Println(key)
}

// Output:
// John
// Charly
// Jenny
// Lisa

मानचित्र क्रमबद्ध करें

जैसा कि मैंने परिचय में उल्लेख किया है, मानचित्र में जानकारी का आदेश नहीं दिया जाता है, इसलिए इसके माध्यम से लूपिंग करते समय हम यह निर्दिष्ट नहीं कर सकते कि यह किस क्रम का पालन करता है, न ही गो गारंटी दे सकता है कि निष्पादन के बीच का क्रम समान है।
जैसा कि हमने एरे और स्लाइस के साथ देखा, मानक लाइब्रेरी में एक सॉर्ट पैकेज होता है जो हमें तत्वों को सॉर्ट करने में मदद करता है: https://pkg.go.dev/sort

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

ages := map[string]int{"John": 33, "Charly": 27, "Jenny": 45, "Lisa": 19}
keys := make([]string, 0, len(ages))
for k := range ages {
    keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
    fmt.Println(k, ages[k])
}

// Output:
// Charly 27
// Jenny 45
// John 33
// Lisa 19

जैसा कि हमने पहले देखा था, हम संक्षिप्त घोषणा के साथ अपना आयु मानचित्र घोषित करते हैं।
हम कुंजियों को संग्रहीत करने के लिए एक स्ट्रिंग स्लाइस बनाते हैं और 0 लंबाई के साथ मेक विधि का उपयोग करते हैं, क्योंकि इस समय हमारे पास कोई कुंजी नहीं है, लेकिन हम अपने मानचित्र की लंबाई के लिए लेन विधि का उपयोग करके इसकी क्षमता को आरक्षित करते हैं।
हम इसकी कुंजियाँ रखने के लिए आयु मानचित्र का अध्ययन करते हैं और उन्हें बनाए गए स्लाइस में जोड़ते हैं।
हम sort.Strings फ़ंक्शन के साथ कुंजियों को वर्णानुक्रम में क्रमबद्ध करते हैं।
हम पहले से ऑर्डर की गई चाबियों के टुकड़े को देखते हैं, और संबंधित कुंजी के साथ मानचित्र तक पहुंचते हैं।
इस तरह हम मानचित्र तक व्यवस्थित तरीके से पहुंच पाएंगे और हम वह तर्क कर सकते हैं जिसकी हमारे कार्यक्रम को आवश्यकता है।

समवर्तीता के साथ समस्याएँ

मानचित्रों के साथ ध्यान रखने योग्य बात यह है कि उनका एक साथ उपयोग करना सुरक्षित नहीं है। यदि ये समवर्ती रीड्स हैं, या तो किसी मान तक पहुंच रहे हैं या किसी सीमा के साथ फॉर के माध्यम से, एक ही समय में कई गोरोइन्स द्वारा इसे एक्सेस करने में कोई समस्या नहीं है।
समस्याग्रस्त मामला तब होता है जब आप किसी मानचित्र के मान को समवर्ती रूप से अपडेट करना चाहते हैं, या तो उसमें तत्वों को जोड़कर या हटाकर, और साथ ही आप इसे दूसरी तरफ से पढ़ रहे हैं, उदाहरण के लिए।
इस स्थिति को हल करने के लिए कई संभावित समाधान हैं, जिनके बारे में मैं अधिक विस्तार से नहीं बताऊंगा, मैं बस उल्लेख करूंगा और उनमें गहराई से उतरने का फैसला आपकी पसंद पर छोड़ दूंगा।

यदि हम मानक लाइब्रेरी से सिंक पैकेज: https://pkg.go.dev/sync का उपयोग करते हैं, तो हम विभिन्न गोरआउट्स के बीच सिंक्रोनाइज़ को नियंत्रित कर सकते हैं।
एक संभावित उपयोग RWMutex प्रकार है जो हमें पढ़ने और लिखने को एक प्रकार में लॉक और अनलॉक करने की अनुमति देता है। इसलिए यदि हमारे पास एक प्रकार है जिसमें एक sync.RWMutex और एक मानचित्र है तो हम नियंत्रित कर सकते हैं कि इसे कब एक्सेस किया जा सकता है।
उसी सिंक पैकेज के भीतर जांच करने के लिए एक और दिलचस्प प्रकार मानचित्र है, जो पहले से ही हमें कार्यों की एक श्रृंखला प्रदान करता है जो हमें अपने मानचित्र के साथ काम करने में मदद करेगा, जिसके साथ अंत में हम पिछले समाधान की तरह मूल रूप से काम नहीं कर पाएंगे।
हम जिस उपयोग के मामले को लागू कर रहे हैं उसके आधार पर, एक या दूसरा हमारे लिए अधिक उपयोगी होगा, और दूसरे से बेहतर कोई नहीं है, यह हमेशा इस बात पर निर्भर करेगा कि हमें क्या चाहिए।

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