एक गोलगप्पे के नक्शे के माध्यम से Iterating

Question

मेरे पास एक प्रकार का नक्शा है: map[string]interface{}

और अंत में, मुझे कुछ ऐसा बनाने के लिए मिलता है (जैसे एक yml फ़ाइल से deserializing के बाद goyaml का उपयोग करके)

mymap = map[foo:map[first: 1] boo: map[second: 2]]

मैं इस नक्शे के माध्यम से कैसे पुनरावृति कर सकता हूं? मैंने निम्नलिखित कोशिश की:

for k, v := range mymap{
...
}

लेकिन मुझे एक त्रुटि मिली:

cannot range over mymap
typechecking loop involving for loop

कृपया मदद करे।

Comments

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

— स्टीव मैककवार्क

Answer 1

उदाहरण के लिए,

package main

import "fmt"

func main() {
    type Map1 map[string]interface{}
    type Map2 map[string]int
    m := Map1{"foo": Map2{"first": 1}, "boo": Map2{"second": 2}}
    //m = map[foo:map[first: 1] boo: map[second: 2]]
    fmt.Println("m:", m)
    for k, v := range m {
        fmt.Println("k:", k, "v:", v)
    }
}

आउटपुट:

m: map[boo:map[second:2] foo:map[first:1]]
k: boo v: map[second:2]
k: foo v: map[first:1]

Answer 2

आप इसे एक पंक्ति से बना सकते हैं:

mymap := map[string]interface{}{"foo": map[string]interface{}{"first": 1}, "boo": map[string]interface{}{"second": 2}}
for k, v := range mymap {
    fmt.Println("k:", k, "v:", v)
}

आउटपुट है:

k: foo v: map[first:1]
k: boo v: map[second:2]

Comments

नीतिवचन जाओ: चतुर मत बनो, स्पष्ट रहो। गो में वन-लाइनर्स लक्ष्य नहीं हैं।

— इनक गमूस

Answer 3

आप इसे इस तरह से मल्टीलाइन में लिख सकते हैं,

$ cat dict.go
package main

import "fmt"

func main() {
        items := map[string]interface{}{
                "foo": map[string]int{
                        "strength": 10,
                        "age": 2000,
                },
                "bar": map[string]int{
                        "strength": 20,
                        "age": 1000,
                },
        }
        for key, value := range items {
                fmt.Println("[", key, "] has items:")
                for k,v := range value.(map[string]int) {
                        fmt.Println("\t-->", k, ":", v)
                }

        }
}

और आउटपुट:

$ go run dict.go
[ foo ] has items:
        --> strength : 10
        --> age : 2000
[ bar ] has items:
        --> strength : 20
        --> age : 1000