你可以使用reflect.DeepEqual，或者你可以实现你自己的函数（这比使用反射更好）：
http://play.golang.org/p/CPdfsYGNy_

m1 := map[string]int{   
    "a":1,
    "b":2,
}
m2 := map[string]int{   
    "a":1,
    "b":2,
}
fmt.Println(reflect.DeepEqual(m1, m2))

reflect.DeepEqual经常被错误地用来比较两个类似的结构体，就像你的问题中那样。
cmp.Equal是比较结构体的更好工具。
要了解为什么反射是不明智的，让我们看看文档：
如果结构值的相应字段（包括导出的和未导出的字段）完全相等，则结构值完全相等。
....
numbers、bool、string和channels -如果使用Go的==运算符相等，则深度相等。
如果我们比较两个相同UTC时间的time.Time值，如果它们的元数据时区不同，则t1 == t2将为false。
go-cmp查找Equal()方法并使用该方法正确比较时间。
范例：

m1 := map[string]int{
    "a": 1,
    "b": 2,
}
m2 := map[string]int{
    "a": 1,
    "b": 2,
}
fmt.Println(cmp.Equal(m1, m2)) // will result in true

重要提示：

使用cmp.Equal时要小心，因为它是may lead to a panic condition
它只用于测试，因为性能不是目标，如果不能比较值，它可能会死机。它的恐慌倾向意味着它不适合生产环境，在那里虚假的恐慌可能是致命的。

下面是如何滚动自己的函数http://play.golang.org/p/Qgw7XuLNhb

func compare(a, b *T) bool {
  if a == b {
    return true
  }
  if a.X != b.X || a.Y != b.Y {
    return false
  }
  if len(a.Z) != len(b.Z) || len(a.M) != len(b.M) {
    return false
  }
  for i, v := range a.Z {
    if b.Z[i] != v {
      return false
    }
  }
  for k, v := range a.M {
    if b.M[k] != v {
      return false
    }
  }
  return true
}

更新：Go 1.18

import (
    "golang.org/x/exp/maps"
    "golang.org/x/exp/slices"
)

func compare(a, b *T) bool {
    if a == b {
        return true
    }
    if a.X != b.X {
        return false
    }
    if a.Y != b.Y {
        return false
    }
    if !slices.Equal(a.Z, b.Z) {
        return false
    }
    return maps.Equal(a.M, b.M)
}

如果你打算在测试中使用它，由于July 2017，你可以使用cmp.Equal和cmpopts.IgnoreFields选项。

func TestPerson(t *testing.T) {
    type person struct {
        ID   int
        Name string
    }

    p1 := person{ID: 1, Name: "john doe"}
    p2 := person{ID: 2, Name: "john doe"}
    println(cmp.Equal(p1, p2))
    println(cmp.Equal(p1, p2, cmpopts.IgnoreFields(person{}, "ID")))

    // Prints:
    // false
    // true
}

如果您在单元测试**中比较它们，一个方便的替代方法是testify中的EqualValues函数。

如果你想比较简单的一级结构，最好和最简单的方法是if语句。
像这样if s1 == s2

举个简单的例子：

type User struct { 
    name      string 
    email           string
} 

func main() {
    u1 := User{
            name: "Iron Man", 
            email: "[email protected]",
    }
    u2 := User{
            name: "Iron Man", 
            email: "[email protected]",
    }
        // Comparing 2 structs
        if u1 == u2 {
            fmt.Println("u1 is equal to u2")
        } else {
            fmt.Println("u1 is not equal to u2")
        }
}

结果：u1 is equal to u2
你可以玩这个here。

Go 1.21

和下面一样，但是maps.Equal现在在标准库中，你可以直接使用它，而不是导入实验性的软件包或自己开发。

转到1.18 ~ 1.20

这个提议（https://github.com/golang/go/issues/47649）是Go泛型未来实现的一部分，它引入了一个新函数来比较两个map，maps.Equal：

// Equal reports whether two maps contain the same key/value pairs.
// Values are compared using ==.
func Equal[M1, M2 constraints.Map[K, V], K, V comparable](m1 M1, m2 M2) bool

示例使用

strMapX := map[string]int{
    "one": 1,
    "two": 2,
}
strMapY := map[string]int{
    "one": 1,
    "two": 2,
}

equal := maps.Equal(strMapX, strMapY)
// equal is true

maps软件包位于golang.org/x/exp/maps中。这是实验性的，超出了Go兼容性保证。他们的目标是将其移动到Go 1.19的标准库中
你可以在gotip playground https://gotipplay.golang.org/p/M0T6bCm1_3m中看到它的工作