So in this answerhere, it's stated that one cannot embed a map into a struct in go. However, I was fiddling around with it, and came up with this and it does actually work, and is pretty straight forward.
package main
import (
"fmt"
"runtime"
)
type record struct {
m map[string]int
}
func main() {
practice := record{m:make(map[string]int)}
practice.m["foo"] = 2
fmt.Println(practice.m)
runtime.GC()
}
this prints map[foo:2]
However, my question is that, are there any negative sides to using this implementation of maps in structs, or are is there more efficient ways to do this?
You can do that, it's absolutely fine.
That isn't "embedding". Embedding means something specific — including a nameless field of a named type in a struct. Your map isn't embedded, it's a regular member with the name "m".
MarshalJSON method") is indeed no, but it's not actually true that embedding a map in a struct is forbidden. If you create a named type that is a map type, you can embed it in a struct just fine. It just doesn't output in JSON the way that the person asking that question would have liked.There aren't any inherent draw backs. Embedding maps in structs is a common practice. The only issues with the implementation would be outside of that, like using a map in favor of a slice when a slice is better. However, that isn't relevant here. Choosing which collection type to use (slice vs array vs map say) is a different discussion and is more based on your data access patterns. In general, it is normal and idiomatic to compose structs with any of Go's collection types (map being one of those).
EDIT: noticed from hobbs answer the misuse of the term embedded in both the question and my answer, as he points out, the map is not 'embedded' that is a specific language feature, this is actually just composition and I should have referred to it as such above.