## Question:

How do you compare two structs? What about two interfaces? Provide examples.

You can compare two structs with the `==` operator, as you would do with other simple types. Just make sure they do not contain any slices, maps, or functions, in which case the code will not be compiled.

``````type Foo struct {
A int
B string
C interface{}
}
a := Foo{A: 1, B: "one", C: "two"}
b := Foo{A: 1, B: "one", C: "two"}

println(a == b)
// Output: true

type Bar struct {
A []int
}
a := Bar{A: []int{1}}
b := Bar{A: []int{1}}

println(a == b)
// Output: invalid operation: a == b (struct containing []int cannot be compared)
``````

You can compare two interfaces with the `==` operator as long as the underlying types are “simple” and identical. Otherwise the code will panic at runtime:

``````var a interface{}
var b interface{}

a = 10
b = 10
println(a == b)
// Output: true

a = []int{1}
b = []int{2}
println(a == b)
// Output: panic: runtime error: comparing uncomparable type []int
``````

Both structs and interfaces which contain maps, slices (but not functions) can be compared with the `reflect.DeepEqual()` function:

``````var a interface{}
var b interface{}

a = []int{1}
b = []int{1}
println(reflect.DeepEqual(a, b))
// Output: true

a = map[string]string{"A": "B"}
b = map[string]string{"A": "B"}
println(reflect.DeepEqual(a, b))
// Output: true

temp := func() {}
a = temp
b = temp
println(reflect.DeepEqual(a, b))
// Output: false
``````

For comparing byte slices, there are nice helper functions in the `bytes` package: `bytes.Equal()``bytes.Compare()`, and `bytes.EqualFold()`. The latter is for comparing text strings disregarding the case, which are much faster than the `reflect.DeepEqual()`.

Keywords: