Go
मैप्स

परिचय

वाक्य - विन्यास

• var mapName का नक्शा [KeyType] ValueType // एक मानचित्र घोषित करें
• var mapName = map [KeyType] ValueType {} // घोषित करें और एक खाली मानचित्र असाइन करें
• var mapName = map [KeyType] ValueType {key1: val1, key2: val2} // घोषित करें और एक मैप असाइन करें
• mapName: = make (map [KeyType] ValueType) // डिफॉल्ट साइज़ मैप को घोषित और आरंभ करें
• mapName: = make (नक्शा [KeyType] ValueType, लंबाई) // घोषित करें और लंबाई आकार के नक्शे को आरंभ करें
• mapName: = मैप [KeyType] ValueType {} // ऑटो-डिक्लेयर करें और इसके साथ एक खाली मैप असाइन करें: =
• mapName: = नक्शा [KeyType] ValueType {key1: value1, key2: value2} // ऑटो-घोषणा और इसके साथ एक मानचित्र असाइन करें: =
• मूल्य: = mapName [कुंजी] // कुंजी द्वारा मूल्य प्राप्त करें
• मान, hasKey: = mapName [कुंजी] // कुंजी द्वारा मान प्राप्त करें, यदि मानचित्र में मौजूद है तो 'hasKey' 'सही' है
• mapName [कुंजी] = मान // कुंजी द्वारा सेट मान

टिप्पणियों

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

आप एक नक्शे के कीवर्ड का उपयोग को परिभाषित map , इसकी कुंजी और अपने मूल्यों के प्रकार के द्वारा पीछा किया:

// Keys are ints, values are ints.
var m1 map[int]int // initialized to nil

// Keys are strings, values are ints.
var m2 map[string]int // initialized to nil

मानचित्र संदर्भ प्रकार हैं, और एक बार परिभाषित होने पर उनका शून्य मान nil । शून्य नक्शे पर लिखने से घबराहट होगी और पढ़े जाने पर हमेशा शून्य मान वापस आएगा।

मानचित्र को इनिशियलाइज़ करने के लिए, make फंक्शन का उपयोग करें:

m := make(map[string]int)

make के दो-पैरामीटर रूप के make , डिफ़ॉल्ट क्षमता को ओवरराइड करते हुए, नक्शे के लिए प्रारंभिक प्रविष्टि क्षमता निर्दिष्ट करना संभव है:

m := make(map[string]int, 30)

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

m := make(map[string]int, 0)

आप एक नक्शा भी बना सकते हैं और घुंघराले कोष्ठक ( {} ) के साथ इसका प्रारंभिक मूल्य निर्धारित कर सकते हैं।

var m map[string]int = map[string]int{"Foo": 20, "Bar": 30}

fmt.Println(m["Foo"]) // outputs 20

निम्नलिखित सभी कथनों का परिणाम चर में समान मूल्य के लिए होता है।

// Declare, initializing to zero value, then assign a literal value.
var m map[string]int
m = map[string]int{}

// Declare and initialize via literal value.
var m = map[string]int{}

// Declare via short variable declaration and initialize with a literal value.
m := map[string]int{}

हम कुछ प्रारंभिक कुंजी / मूल्य जोड़े के साथ एक नया नक्शा बनाने के लिए मानचित्र शाब्दिक का उपयोग भी कर सकते हैं।

कुंजी प्रकार किसी भी तुलनीय प्रकार का हो सकता है; विशेष रूप से, यह फ़ंक्शन, नक्शे और स्लाइस को बाहर करता है । मूल्य प्रकार किसी भी प्रकार का हो सकता है, जिसमें कस्टम प्रकार या interface{} ।

type Person struct {
    FirstName string
    LastName  string
}

// Declare via short variable declaration and initialize with make.
m := make(map[string]Person)

// Declare, initializing to zero value, then assign a literal value.
var m map[string]Person
m = map[string]Person{}

// Declare and initialize via literal value.
var m = map[string]Person{}

// Declare via short variable declaration and initialize with a literal value.
m := map[string]Person{}

नक्शा बनाना

एक समग्र शाब्दिक का उपयोग करके एक ही बयान में एक मानचित्र को घोषित और प्रारंभिक कर सकता है।

स्वचालित प्रकार लघु चर घोषणा का उपयोग करना:

mapIntInt := map[int]int{10: 100, 20: 100, 30: 1000}
mapIntString := map[int]string{10: "foo", 20: "bar", 30: "baz"}
mapStringInt := map[string]int{"foo": 10, "bar": 20, "baz": 30}
mapStringString := map[string]string{"foo": "one", "bar": "two", "baz": "three"}

समान कोड, लेकिन परिवर्तनीय प्रकारों के साथ:

var mapIntInt = map[int]int{10: 100, 20: 100, 30: 1000}
var mapIntString = map[int]string{10: "foo", 20: "bar", 30: "baz"}
var mapStringInt = map[string]int{"foo": 10, "bar": 20, "baz": 30}
var mapStringString = map[string]string{"foo": "one", "bar": "two", "baz": "three"}

आप एक नक्शे में अपनी खुद की संरचना भी शामिल कर सकते हैं:

आप मूल्य के रूप में कस्टम प्रकार का उपयोग कर सकते हैं:

// Custom struct types
type Person struct {
  FirstName, LastName string
}

var mapStringPerson = map[string]Person{
  "john": Person{"John", "Doe"},
  "jane": Person{"Jane", "Doe"}}
mapStringPerson := map[string]Person{
  "john": Person{"John", "Doe"},
  "jane": Person{"Jane", "Doe"}}

आपकी संरचना मानचित्र की कुंजी भी हो सकती है:

type RouteHit struct {
    Domain string
    Route  string
}

var hitMap = map[RouteHit]int{
  RouteHit{"example.com","/home"}: 1,
  RouteHit{"example.com","/help"}: 2}
hitMap := map[RouteHit]int{
  RouteHit{"example.com","/home"}: 1,
  RouteHit{"example.com","/help"}: 2}

आप कोष्ठक {} भीतर किसी भी मूल्य को दर्ज नहीं करके केवल एक खाली नक्शा बना सकते हैं।

mapIntInt := map[int]int{}
mapIntString := map[int]string{}
mapStringInt := map[string]int{}
mapStringString := map[string]string{}
mapStringPerson := map[string]Person{}

आप एक चर को निर्दिष्ट करने की आवश्यकता के बिना, सीधे एक मानचित्र बना सकते हैं और उसका उपयोग कर सकते हैं। हालाँकि, आपको घोषणा और सामग्री दोनों को निर्दिष्ट करना होगा।

// using a map as argument for fmt.Println()
fmt.Println(map[string]string{
  "FirstName": "John",
  "LastName": "Doe",
  "Age": "30"})

// equivalent to
data := map[string]string{
  "FirstName": "John",
  "LastName": "Doe",
  "Age": "30"}
fmt.Println(data)

एक नक्शे का शून्य मूल्य

एक map का शून्य मान nil और इसकी लंबाई 0 ।

var m map[string]string
fmt.Println(m == nil) // true
fmt.Println(len(m) ==0) // true

nil मानचित्र में कोई कुंजी नहीं है और न ही चाबियाँ जोड़ी जा सकती हैं। एक nil मानचित्र एक खाली मानचित्र की तरह व्यवहार करता है यदि इससे पढ़ा जाता है लेकिन यदि लिखा जाए तो एक रनटाइम आतंक का कारण बनता है।

var m map[string]string

// reading
m["foo"] == "" // true. Remember "" is the zero value for a string
_, ok = m["foo"] // ok == false

// writing
m["foo"] = "bar" // panic: assignment to entry in nil map

आपको शून्य मान मानचित्र से पढ़ने या लिखने की कोशिश नहीं करनी चाहिए। इसके बजाय, नक्शा (साथ प्रारंभ make उपयोग करने से पहले या असाइनमेंट)।

var m map[string]string
m = make(map[string]string) // OR m = map[string]string{}
m["foo"] = "bar"

एक मानचित्र के तत्वों को बदलना

import fmt

people := map[string]int{
  "john": 30,
  "jane": 29,
  "mark": 11,
}

for key, value := range people {
  fmt.Println("Name:", key, "Age:", value)
}

ध्यान दें कि जब रेंज लूप वाले नक्शे पर पुनरावृति होती है, तो पुनरावृत्ति क्रम निर्दिष्ट नहीं होता है और एक पुनरावृत्ति से अगले तक समान होने की गारंटी नहीं होती है।

आप या तो कुंजी या नक्शे के मूल्यों को त्याग सकते हैं, यदि आप केवल चाबियाँ हड़पने के लिए देख रहे हैं या बस मूल्यों को पकड़ो।

मानचित्र की कुंजियों को बदलना

people := map[string]int{
  "john": 30,
  "jane": 29,
  "mark": 11,
}

for key, _ := range people {
  fmt.Println("Name:", key)
}

यदि आप केवल कुंजियों की तलाश कर रहे हैं, क्योंकि वे पहला मूल्य हैं, तो आप केवल अंडरस्कोर छोड़ सकते हैं:

for key := range people {
  fmt.Println("Name:", key)
}

ध्यान दें कि जब रेंज लूप वाले नक्शे पर पुनरावृति होती है, तो पुनरावृत्ति क्रम निर्दिष्ट नहीं होता है और एक पुनरावृत्ति से अगले तक समान होने की गारंटी नहीं होती है।

एक मानचित्र तत्व को हटाना

अंतर्निहित फ़ंक्शन delete गए तत्व को एक नक्शे से निर्दिष्ट कुंजी के साथ हटा देता है।

people := map[string]int{"john": 30, "jane": 29}
fmt.Println(people) // map[john:30 jane:29]

delete(people, "john")
fmt.Println(people) // map[jane:29]

यदि map nil या ऐसा कोई तत्व नहीं है, तो delete का कोई प्रभाव नहीं है।

people := map[string]int{"john": 30, "jane": 29}
fmt.Println(people) // map[john:30 jane:29]

delete(people, "notfound")
fmt.Println(people) // map[john:30 jane:29]

var something map[string]int
delete(something, "notfound") // no-op

मानचित्र तत्वों की गिनती

अंतर्निहित फ़ंक्शन len map में तत्वों की संख्या देता है

m := map[string]int{}
len(m) // 0

m["foo"] = 1
len(m) // 1

यदि एक चर nil नक्शे की ओर nil , तो len 0 देता है।

var m map[string]int
len(m) // 0

मानचित्रों का समवर्ती अभिगम

जाने के लिए नक्शे संगामिति के लिए सुरक्षित नहीं हैं। आप उन पर पढ़ने और लिखने के लिए ताला लगा सकते हैं यदि आप उन्हें समवर्ती रूप से एक्सेस करेंगे। आमतौर पर सबसे अच्छा विकल्प sync.RWMutex का उपयोग करना है। sync.RWMutex क्योंकि आप पढ़ सकते हैं और ताले लिख सकते हैं। हालाँकि, एक sync.Mutex । sync.Mutex भी इस्तेमाल किया जा सकता है।

type RWMap struct {
    sync.RWMutex
    m map[string]int
}

// Get is a wrapper for getting the value from the underlying map
func (r RWMap) Get(key string) int {
    r.RLock()
    defer r.RUnlock()
    return r.m[key]
}

// Set is a wrapper for setting the value of a key in the underlying map
func (r RWMap) Set(key string, val int) {
    r.Lock()
    defer r.Unlock()
    r.m[key] = val
}

// Inc increases the value in the RWMap for a key.
//   This is more pleasant than r.Set(key, r.Get(key)++)
func (r RWMap) Inc(key string) {
    r.Lock()
    defer r.Unlock()
    r.m[key]++
}

func main() {

    // Init
    counter := RWMap{m: make(map[string]int)}

    // Get a Read Lock
    counter.RLock()
    _ = counter.["Key"]
    counter.RUnlock()

    // the above could be replaced with
    _ = counter.Get("Key")

    // Get a write Lock
    counter.Lock()
    counter.m["some_key"]++
    counter.Unlock()

    // above would need to be written as 
    counter.Inc("some_key")
}

आवरण कार्यों का व्यापार बंद अंतर्निहित नक्शे के सार्वजनिक उपयोग और उचित ताले का सही ढंग से उपयोग करने के बीच है।

मूल्यों के रूप में स्लाइस के साथ नक्शे बनाना

m := make(map[string][]int)

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

// m["key1"] == nil && len(m["key1"]) == 0
m["key1"] = append(m["key1"], 1)
// len(m["key1"]) == 1

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

delete(m, "key1")
// m["key1"] == nil

एक नक्शे में तत्व के लिए जाँच करें

मानचित्र से मान प्राप्त करने के लिए, आपको बस कुछ करना होगा: 00

value := mapName[ key ]

यदि मानचित्र में कुंजी है, तो यह संबंधित मान लौटाता है।
यदि नहीं, तो यह मानचित्र के मूल्य प्रकार का शून्य-मान लौटाता है ( 0 यदि int मानों का मानचित्र, "" यदि string मानों का मानचित्र ...)

m  := map[string]string{"foo": "foo_value", "bar": ""}
k  := m["foo"]  // returns "foo_value" since that is the value stored in the map
k2 := m["bar"]  // returns "" since that is the value stored in the map
k3 := m["nop"]  // returns "" since the key does not exist, and "" is the string type's zero value

खाली मानों और गैर-मौजूद कुंजियों के बीच अंतर करने के लिए, आप नक्शे के उपयोग के दूसरे लौटे हुए मूल्य ( value, hasKey := map["key"] )।

यह दूसरा मूल्य boolean टाइप किया गया है, और होगा:

• true जब मूल्य नक्शे में है,
• false जब नक्शे में दी गई कुंजी नहीं है।

निम्नलिखित उदाहरण देखें:

value, hasKey = m[ key ]
if hasKey {
    // the map contains the given key, so we can safely use the value
    // If value is zero-value, it's because the zero-value was pushed to the map
} else {
    // The map does not have the given key
    // the value will be the zero-value of the map's type
}

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

people := map[string]int{
  "john": 30,
  "jane": 29,
  "mark": 11,
}

for _, value := range people {
  fmt.Println("Age:", value)
}

ध्यान दें कि जब रेंज लूप वाले नक्शे पर पुनरावृति होती है, तो पुनरावृत्ति क्रम निर्दिष्ट नहीं होता है और एक पुनरावृत्ति से अगले तक समान होने की गारंटी नहीं होती है।

एक मानचित्र की प्रतिलिपि बनाएँ

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

// Create the original map
originalMap := make(map[string]int)
originalMap["one"] = 1
originalMap["two"] = 2

// Create the target map
targetMap := make(map[string]int)

// Copy from the original map to the target map
for key, value := range originalMap {
  targetMap[key] = value
}

एक सेट के रूप में मानचित्र का उपयोग करना

कुछ भाषाओं में सेट के लिए एक देशी संरचना होती है। गो में एक सेट बनाने के लिए, सेट के मूल्य प्रकार से खाली संरचना ( map[Type]struct{} ) के लिए मानचित्र का उपयोग करना सबसे अच्छा अभ्यास है।

उदाहरण के लिए, तार के साथ:

// To initialize a set of strings:
greetings := map[string]struct{}{
    "hi":    {},
    "hello": {},
}

// To delete a value:
delete(greetings, "hi")

// To add a value:
greetings["hey"] = struct{}{}

// To check if a value is in the set:
if _, ok := greetings["hey"]; ok {
    fmt.Println("hey is in greetings")
}