golang another func change map of a struct

I'm a new one on go.Now I have a question about functoin pass variable.Here is the code:

type User struct {
	Name string
	Map  map[string]string
}
func main() {
	u := User{Name: "Leto"}
	u.Map = make(map[string]string)
	fmt.Println("before --------")
	fmt.Println(unsafe.Pointer(&u))
	fmt.Println(unsafe.Pointer(&(u.Map)))
	fmt.Println(u)
	Modify(u)
	fmt.Println("after --------")
	fmt.Println(u)
}
func Modify(u User) {
	fmt.Println("in func --------")
	fmt.Println(unsafe.Pointer(&u))
	fmt.Println(unsafe.Pointer(&(u.Map)))
	u.Name = "Paul"
	u.Map["t"] = "t"
}

code above output:

before --------
0xc04203a4c0
0xc04203a4d0
{Leto map[]}
in func --------
0xc04203a500
0xc04203a510
after --------
{Leto map[t:t]}

in Modify func i know user is a copy ,so change name not work is ok ,but why change Map effect out user struct ?

We need to understand how memory allocation is working here in each call:

  u := User{Name: "Leto"}
// u is an object of type User
// after this line memory has been allocated to both the
// properties u.Name(string) and u.Map(reference)
// lets say allocated memory address for u.Name starts with x
// for u.Map it starts with y, and note that u.Map is a reference i.e. 
// the value contained in it will be a different memory address which
// will be the starting memory address of the actual map
// right now the value written at y is nil since it 
// does not point to any memory address
u.Map = make(map[string]string)
// now value of y has been updated to z (which is the 
// memory address of the beginning of the map initialized 
// with make call) 
fmt.Println("before --------")
fmt.Println(unsafe.Pointer(&u))
fmt.Println(unsafe.Pointer(&(u.Map)))
fmt.Println(u)
// here you are about to pass object by value 
// so basically a new object will be created of type User
// lets talk about how copy of this object will be created
// copy of u.Name will have a new address 
// lets call it x1 and the value "Leto" too will be 
// copied to memory address starting with x1
// copy of u.Map will have a new address too lets call it 
// y1 and its value z will be copied too to the memory address y1
// I think you must have got your answer by now. 
// Basically the newly copied object's property u.Map and 
// the old one's u.Map both points to the same memory address "z" 
// and hence whosoever updates the map the other one will see it
Modify(u)
fmt.Println("after --------")
fmt.Println(u)

You should use &User and *User respectively in your assignment and modify operations.

Check this https://play.golang.org/p/tDh1JBpK-t

Its always better to work with pointers to structs.

Slices, maps and channels are reference types. so they are always passed by reference.