Go में नक्शा कैसे साफ़ करें?

Question

मैं .clear() आदिम प्रकार के लिए सी ++ फ़ंक्शन की तरह कुछ देख रहा हूं map।

या मुझे इसके बजाय एक नया नक्शा बनाना चाहिए?

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

var a map[string]string
var b map[string]string

func main() {
    a = make(map[string]string)
    b=a
    a["hello"]="world"
    a = nil
    fmt.Println(b["hello"])
}

मेरा मतलब है, यह अभी भी .clear()c ++ में फ़ंक्शन से अलग है , जो ऑब्जेक्ट में सामग्री को साफ करेगा।

Comments

: भी इस चर्चा को देखने के groups.google.com/d/topic/golang-nuts/6yHDC7IYCj4/discussion

— perreal

वहाँ भी बनाया शुद्ध पर चर्चा में है

— 7

Answer 1

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

तो हाँ, आपको शायद कहना चाहिए

mymap = make(map[keytype]valtype)

---

यदि आपको वास्तव में जो भी कारण है उसके लिए मौजूदा नक्शे को साफ़ करने की आवश्यकता है, यह काफी सरल है:

for k := range m {
    delete(m, k)
}

Comments

तो एक-एक करके तत्वों को हटाना ही एकमात्र तरीका है?

— 1

@ विल्विन: हां। ऐसा करने के लिए कोई अंतर्निहित फ़ंक्शन नहीं है, और आपके पास लाइब्रेरी फ़ंक्शन नहीं हो सकता है जो मनमाने नक्शे के लिए ऐसा करता है। लेकिन यह केवल 3 लाइनों है।

— लिली बैलार्ड

क्या सभी मूल्यों के माध्यम से पुनरावृत्ति करते हुए मानचित्र की सामग्री को संशोधित करना वास्तव में ठीक है? अन्य भाषाएँ इसके साथ सही ढंग से काम नहीं करेंगी।

— जॉन जेफरी

@ जॉन जॉफरी: मैंने इसे पोस्ट करने से पहले इसका परीक्षण किया। काम करने लगता है। युक्ति से वास्तविक भाषा कहती है कि The iteration order over maps is not specified and is not guaranteed to be the same from one iteration to the next. If map entries that have not yet been reached are deleted during iteration, the corresponding iteration values will not be produced. If map entries are inserted during iteration, the behavior is implementation-dependent, but the iteration values for each entry will be produced at most once. If the map is nil, the number of iterations is 0.इससे पता चलता है कि यह समर्थित है।

— लिली बॉलर

गो 1.11 से शुरू होकर, इस फॉर्म के मैप क्लियरिंग ऑपरेशन को कंपाइलर द्वारा ऑप्टिमाइज़ किया जाता है। github.com/golang/go/blob/master/doc/go1.11.html

— बेंजामिन बी।

Answer 2

C ++ के विपरीत, गो एक कचरा एकत्रित भाषा है। आपको चीजों को थोड़ा अलग तरीके से सोचने की जरूरत है।

जब आप एक नया नक्शा बनाते हैं

a := map[string]string{"hello": "world"}
a = make(map[string]string)

मूल नक्शे को अंततः एकत्र किया जाएगा; आपको इसे स्वयं साफ़ करने की आवश्यकता नहीं है। लेकिन याद रखें कि नक्शे (और स्लाइस) संदर्भ प्रकार हैं; आप उन्हें बनाते हैं make()। अंतर्निहित नक्शे को केवल तब ही कचरा-संग्रहित किया जाएगा, जब इसके कोई संदर्भ न हों। इस प्रकार, जब आप करते हैं

a := map[string]string{"hello": "world"}
b := a
a = make(map[string]string)

मूल सरणी कचरा एकत्र नहीं किया जाएगा (जब तक बी कचरा-एकत्र या बी कुछ और को संदर्भित नहीं करता है)।

Answer 3

// Method - I , say book is name of map
for k := range book {
    delete(book, k)
}

// Method - II
book = make(map[string]int)

// Method - III
book = map[string]int{}

Answer 4

यदि आप एक लूप में ऐसा करने की कोशिश कर रहे हैं, तो आप मानचित्रण को अपने लिए खाली करने के लिए प्रारंभिक लाभ उठा सकते हैं। उदाहरण के लिए:

for i:=0; i<2; i++ {
    animalNames := make(map[string]string)
    switch i {
        case 0:
            animalNames["cat"] = "Patches"
        case 1:
            animalNames["dog"] = "Spot";
    }

    fmt.Println("For map instance", i)
    for key, value := range animalNames {
        fmt.Println(key, value)
    }
    fmt.Println("-----------\n")
}

जब आप इसे निष्पादित करते हैं, तो यह पिछले मानचित्र को हटा देता है और खाली मानचित्र के साथ शुरू होता है। यह आउटपुट द्वारा सत्यापित है:

$ go run maptests.go 
For map instance 0
cat Patches
-----------

For map instance 1
dog Spot
-----------

Comments

यह नक्शे को साफ नहीं कर रहा है लेकिन एक नया नक्शा बना रहा है और प्रत्येक लूप के नाम के साथ एक स्थानीय चर के लिए बाध्य है।

— डेलानी