Comparing and Copying Structs

A struct in Go is a value, the same way a number is. The variable holds the fields themselves, not a reference to fields kept somewhere else. That single fact explains both how structs copy and how they compare.

Copying

Assignment copies every field into the new variable. After b := a, changing b.X leaves a.X alone; they are two separate values. Passing a struct to a function copies it too, so the function works on its own copy and cannot change the caller's value. Returning a struct copies it back out.

Comparing

== on two structs of the same type compares them field by field and is true only when every pair of fields is equal. != is the opposite. This is allowed only when every field type is comparable. Numbers, strings, booleans, pointers, channels, interfaces, arrays of comparable types, and structs whose fields are all comparable are comparable. Slices, maps and functions are not. A comparable struct can also be used as a map key, which is how a pair of coordinates becomes one key.

What trips people up

The copy is shallow. A slice or map field copies the small header that refers to the elements, not the elements, so the copy and the original share the same underlying data. Change an element through one and it changes for both. Separately, == on a struct that contains a slice, map or function field is a compile error, not a false result; use reflect.DeepEqual, or compare the fields you actually care about. A pointer field compares addresses, so two structs pointing at equal-looking but separate values are not equal.

package main

import "fmt"

type Point struct {
	X int
	Y int
}

type Tags struct {
	Names []string
}

func main() {
	a := Point{X: 1, Y: 2}
	b := Point{X: 1, Y: 2}

	// == compares field by field. Two separate values can still be equal.
	fmt.Println(a == b)

	// Assignment copies every field, so c is independent of a.
	c := a
	c.X = 99
	fmt.Println(a.X, c.X)

	// Tags holds a slice, so Tags values cannot be compared with ==.
	// Writing Tags{} == Tags{} would stop this program compiling.
	t1 := Tags{Names: []string{"go"}}

	// The copy gets its own header, pointing at the same elements.
	t2 := t1
	t2.Names[0] = "rust"
	fmt.Println(t1.Names[0])
}

// Output:
// true
// 1 99
// rust

package main

import "fmt"

type Cell struct {
	Row int
	Col int
}

func main() {
	seen := map[Cell]string{}
	seen[Cell{Row: 1, Col: 2}] = "x"

	// Equal field values mean the same key, so this overwrites.
	seen[Cell{Row: 1, Col: 2}] = "y"
	fmt.Println(len(seen), seen[Cell{Row: 1, Col: 2}])

	_, ok := seen[Cell{Row: 9, Col: 9}]
	fmt.Println(ok)
}

// Output:
// 1 y
// false

package main

import (
	"fmt"
	"reflect"
)

type Config struct {
	Hosts []string
	Debug bool
}

func main() {
	a := Config{Hosts: []string{"a", "b"}}
	b := Config{Hosts: []string{"a", "b"}}

	// a == b would not compile, because Hosts is a slice.
	fmt.Println(reflect.DeepEqual(a, b))

	b.Hosts[1] = "c"
	fmt.Println(reflect.DeepEqual(a, b))
}

// Output:
// true
// false

package main

import "fmt"

type Box struct {
	Name string
	Link *Box
}

func main() {
	a := Box{Name: "a"}
	x := Box{Name: "same", Link: &a}
	y := Box{Name: "same", Link: &a}

	// Both Link fields hold the same address, so x and y are equal.
	fmt.Println(x == y)

	b := Box{Name: "a"}
	z := Box{Name: "same", Link: &b}

	// b has the same fields as a but is stored elsewhere.
	fmt.Println(x == z, *x.Link == *z.Link)
}

// Output:
// true
// false true