We’ve already mentioned that struct tags are ignored when doing conversion between struct types. Now we see where that’s defined, along with an example:

Conversions

…

Struct tags are ignored when comparing struct types for identity for the purpose of conversion:

type Person struct {
	Name    string
	Address *struct {
		Street string
		City   string
	}
}

var data *struct {
	Name    string `json:"name"`
	Address *struct {
		Street string `json:"street"`
		City   string `json:"city"`
	} `json:"address"`
}

var person = (*Person)(data)  // ignoring tags, the underlying types are identical

I don’t think there’s much else to say about that, so let’s move on, and finish up this section.

Specific rules apply to (non-constant) conversions between numeric types or to and from a string type. These conversions may change the representation of x and incur a run-time cost. All other conversions only change the type but not the representation of x.

In other words, some conversions (e.g. from int64 to int32) may be lossy under some circumstances. Or as an example of run-time cost, when converting from []byte to string, new memory must be allocated and the value copied, since a string is immutable and []byte is not. This can have a big impact on runtime performance in some cases.

There is no linguistic mechanism to convert between pointers and integers. The package unsafe implements this functionality under restricted circumstances.

If you’ve used C or C++, and were wondering about pointer arithmetic in Go, this is the line that shatters those dreams. There is no pointer arithmetic in Go, the language. You can still do it, in some cases, using the unsafe package, but as the label says: It’s unsafe. The use of unsafe will not work across all platforms, or even different versions of Go. Use at your own risk.

Quotes from The Go Programming Language Specification Language version go1.22 (Feb 6, 2024)