# 类型转换、赋值和值比较规则大全

此篇文章将列出Go中所有的类型转换、赋值和值比较规则。 请注意：在阐述这些规则的时候，自定义泛型中频繁使用的类型参数类型被特意忽略掉了。 也就是说，本文不考虑涉及到自定义泛型的情形。

### 类型转换规则大全

在Go中，如果一个值`v`可以被显式地转换为类型`T`，则此转换可以使用语法形式`(T)(v)`来表示。 在大多数情况下，特别是`T`为一个类型名（即一个标识符）时，此形式可简化为`T(v)`。

当我们说一个值`x`可以被隐式转换为一个类型`T`，这同时也意味着`x`可以被显式转换为类型`T`。

#### 1. 显然的类型转换规则

如果两个类型表示着同一个类型，则它们的值可以相互隐式转换为这两个类型中的任意一个。
比如，

- 类型`byte`和`uint8`的任何值可以转换为这两个类型中的任意一个。
- 类型`rune`和`int32`的任何值可以转换为这两个类型中的任意一个。
- 类型`[]byte`和`[]uint8`的任何值可以转换为这两个类型中的任意一个。

此条规则没什么可解释的，无论你是否认为此种情况中发生了转换。

#### 2. 底层类型相关的类型转换规则

给定一个非接口值`x`和一个非接口类型`T`，并假设`x`的类型为`Tx`，

- 如果类型`Tx`和`T`的底层类型相同（忽略掉结构体字段标签），则`x`可以被显式转换为类型`T`。
- 如果类型`Tx`和`T`中至少有一个是无名类型并且它们的底层类型相同（考虑结构体字段标签），则`x`可以被隐式转换为类型`T`。
- 如果类型`Tx`和`T`的底层类型不同，但是两者都是无名的指针类型并且它们的基类型的底层类型相同（忽略掉结构体字段标签），则`x`可以（而且只能）被显式转换为类型`T`。

（注意：两处“忽略掉结构体字段标签”从Go 1.8开始生效。）

一个例子：

    package main

    func main() {
    	// 类型[]int、IntSlice和MySlice共享底层类型：[]int。
    	type IntSlice []int
    	type MySlice  []int
    	type Foo = struct{n int `foo`}
    	type Bar = struct{n int `bar`}

    	var s  = []int{}
    	var is = IntSlice{}
    	var ms = MySlice{}
    	var x map[Bar]Foo
    	var y map[Foo]Bar

    	// 这两行隐式转换编译不通过。
    	/*
    	is = ms
    	ms = is
    	*/

    	// 必须使用显式转换。
    	is = IntSlice(ms)
    	ms = MySlice(is)
    	x = map[Bar]Foo(y)
    	y = map[Foo]Bar(x)

    	// 这些隐式转换是没问题的。
    	s = is
    	is = s
    	s = ms
    	ms = s
    }

指针相关的转换例子：

    package main

    func main() {
    	type MyInt int
    	type IntPtr *int
    	type MyIntPtr *MyInt

    	var pi = new(int)  // pi的类型为*int
    	var ip IntPtr = pi // 没问题，因为底层类型相同
    	                   // 并且pi的类型为无名类型。

    	// var _ *MyInt = pi // 不能隐式转换
    	var _ = (*MyInt)(pi) // 显式转换是没问题的

    	// 类型*int的值不能被直接转换为类型MyIntPtr，
    	// 但是可以间接地转换过去。
    	/*
    	var _ MyIntPtr = pi  // 不能隐式转换
    	var _ = MyIntPtr(pi) // 也不能显式转换
    	*/
    	var _ MyIntPtr = (*MyInt)(pi)  // 间接隐式转换没问题
    	var _ = MyIntPtr((*MyInt)(pi)) // 间接显式转换没问题

    	// 类型IntPtr的值不能被直接转换为类型MyIntPtr，
    	// 但是可以间接地转换过去。
    	/*
    	var _ MyIntPtr = ip  // 不能隐式转换
    	var _ = MyIntPtr(ip) // 也不能显式转换
    	*/
    	// 间接隐式或者显式转换都是没问题的。
    	var _ MyIntPtr = (*MyInt)((*int)(ip))  // ok
    	var _ = MyIntPtr((*MyInt)((*int)(ip))) // ok
    }

#### 3. 通道相关的类型转换规则

给定一个通道值`x`，假设它的类型`Tx`是一个双向通道类型，`T`也是一个通道类型（无论是双向的还是单向的）。如果`Tx`和`T`的元素类型相同并且它们中至少有一个为无名类型，则`x`可以被隐式转换为类型`T`。
一个例子：

    package main

    func main() {
    	type C chan string
    	type C1 chan<- string
    	type C2 <-chan string

    	var ca C
    	var cb chan string

    	cb = ca // ok，因为底层类型相同
    	ca = cb // ok，因为底层类型相同

    	// 这4行都满足此第3条转换规则的条件。
    	var _, _ chan<- string = ca, cb // ok
    	var _, _ <-chan string = ca, cb // ok
    	var _ C1 = cb                   // ok
    	var _ C2 = cb                   // ok

    	// 类型C的值不能直接转换为类型C1或C2。
    	/*
    	var _ = C1(ca) // compile error
    	var _ = C2(ca) // compile error
    	*/

    	// 但是类型C的值可以间接转换为类型C1或C2。
    	var _ = C1((chan<- string)(ca)) // ok
    	var _ = C2((<-chan string)(ca)) // ok
    	var _ C1 = (chan<- string)(ca)  // ok
    	var _ C2 = (<-chan string)(ca)  // ok
    }

#### 4. 和接口实现相关的类型转换规则

给定一个值`x`和一个接口类型`I`，如果`x`的类型（或者默认类型）为`Tx`并且类型`Tx`实现了接口类型`I`，则`x`可以被隐式转换为类型`I`。 此转换的结果为一个类型为`I`的接口值。此接口值包裹了

- `x`的一个副本（如果`Tx`是一个非接口值）；
- `x`的动态值的一个副本（如果`Tx`是一个接口值）。

请阅读接口一文获取更多详情和示例。

#### 5. 类型不确定值相关的类型转换规则

如果一个类型不确定值可以表示为类型`T`的值，则它可以被隐式转换为类型`T`。
一个例子：

    package main

    func main() {
    	var _ []int = nil
    	var _ map[string]int = nil
    	var _ chan string = nil
    	var _ func()() = nil
    	var _ *bool = nil
    	var _ interface{} = nil

    	var _ int = 123.0
    	var _ float64 = 123
    	var _ int32 = 1.23e2
    	var _ int8 = 1 + 0i
    }

#### 6. 常量相关的类型转换规则

（此规则和上一条规则有些重叠。）

常量的类型转换结果一般仍然是一个常量（除非目标类型不是基本类型）。

给定一个常量值`x`和一个基本类型`T`，如果`x`可以表示成类型`T`的一个值，则`x`可以被显式地转换为类型`T`；特别地，如果`x`是一个类型不确定值，则它可以被隐式转换为类型`T`。
一个例子：

    package main

    func main() {
    	// 这些隐式转换都是合法的。
    	const I = 123
    	const I1, I2 int8 = 0x7F, -0x80
    	const I3, I4 int8 = I, 0.0
    	const F = 0.123456789
    	const F32 float32 = F
    	const F32b float32 = I
    	const F64 float64 = F
    	const C1, C2 complex64 = F, I

    	// const F64b float64 = I3 // 这个赋值编译将失败
    	const F64b = float64(I3)   // 这个编译没问题

    	// const I5 int = C2 // 这个赋值编译将失败
    	const I5 = int(C2)   // 这个编译没问题
    }

#### 7. 非常量数值转换规则

非常量浮点数和整数值可以被显式转换为任何浮点数和整数类型。
非常量复数值可以被显式转换为任何复数类型。
注意，

- 非常量复数值不能被转换为浮点数或整数类型。
- 非常量浮点数和整数值不能被转换为复数类型。
- 在非常量数值的转换过程中，溢出和舍入是允许的。当一个浮点数被转换为整数时，小数部分将被舍弃（向零靠拢）。

一个例子：

    package main

    import "fmt"

    func main() {
    	var a, b = 1.6, -1.6 // 类型均为float64
    	fmt.Println(int(a), int(b)) // 1 -1

    	var i, j int16 = 0x7FFF, -0x8000
    	fmt.Println(int8(i), uint16(j)) // -1 32768

    	var c1 complex64 = 1 + 2i
    	var _ = complex128(c1)
    }

#### 8. 字符串相关的转换规则

如果一个值的类型（或者默认类型）为一个整数类型，则此值可以被当作一个码点值（rune值）显式转换为任何字符串类型。
一个字符串可以被显式转换为一个字节切片类型，反之亦然。 字节切片类型是指底层类型为`[]byte`的类型。
一个字符串可以被显式转换为一个码点切片类型，反之亦然。 码点切片类型是指底层类型为`[]rune`的类型。

请阅读字符串一文获取更多详情和示例。

#### 9. 切片相关的类型转换规则

从Go 1.17开始，一个切片可以被转化为一个相同元素类型的数组的指针类型。 但是如果数组的长度大于被转化切片的长度，则将导致恐慌产生。

这里有一个例子。

从Go 1.20开始，一个切片可以被转化为一个相同元素类型的数组。 但是如果数组的长度大于被转化切片的长度，则将导致恐慌产生。

这里有一个例子。

#### 10. 非类型安全指针相关的类型转换规则

非类型安全指针类型是指底层类型为`unsafe.Pointer`的类型。

任何类型安全指针类型的值可以被显式转化为一个非类型安全指针类型，反之亦然。
任何uintptr值可以被显式转化为一个非类型安全指针类型，反之亦然。

请阅读非类型安全指针一文获取详情和示例。

### 赋值规则

赋值可以看作是隐式类型转换。 各种隐式转换规则在上一节中已经列出。

除了这些规则，赋值语句中的目标值必须为一个可寻址的值、一个映射元素表达式或者一个空标识符。

在一个赋值中，源值被复制给了目标值。精确地说，源值的直接部分被复制给了目标值。

注意：函数传参和结果返回其实都是赋值。

### 值比较规则

Go白皮书提到：

在任何比较中，第一个比较值必须能被赋值给第二个比较值的类型，或者反之。

所以，值比较规则和赋值规则非常相似。 换句话说，两个值是否可以比较取决于其中一个值是否可以隐式转换为另一个值的类型。 很简单？此规则描述基本正确，但是存在另外一条优先级更高的规则：

如果一个比较表达式中的两个比较值均为类型确定值，则它们的类型必须都属于可比较类型。

按照上面这条规则，如果一个不可比较类型（肯定是一个非接口类型）实现了一个接口类型，则比较这两个类型的值是非法的，即使前者的值可以隐式转化为后者。

注意，尽管切片/映射/函数类型为不可比较类型，但是它们的值可以和类型不确定的预声明`nil`标识符比较。

上述规则并未覆盖所有的情况。如果两个值均为类型不确定值，它们可以比较吗？这种情况的规则比较简单：

- 两个类型不确定的布尔值可以相互比较。
- 两个类型不确定的数字值可以相互比较。
- 两个类型不确定的字符串值可以相互比较。

两个类型不确定的数字值的比较结果服从直觉。

注意，两个类型不确定的nil值不能相互比较。

任何比较的结果均为一个类型不确定的布尔值。

一些值比较的例子：

    package main

    // 一些类型为不可比较类型的变量。
    var s []int
    var m map[int]int
    var f func()()
    var t struct {x []int}
    var a [5]map[int]int

    func main() {
    	// 这些比较编译不通过。
    	/*
    	_ = s == s
    	_ = m == m
    	_ = f == f
    	_ = t == t
    	_ = a == a
    	_ = nil == nil
    	_ = s == interface{}(nil)
    	_ = m == interface{}(nil)
    	_ = f == interface{}(nil)
    	*/

    	// 这些比较编译都没问题。
    	_ = s == nil
    	_ = m == nil
    	_ = f == nil
    	_ = 123 == interface{}(nil)
    	_ = true == interface{}(nil)
    	_ = "abc" == interface{}(nil)
    }

#### 两个值是如何进行比较的？

假设两个值可以相互比较，并且它们的类型同为`T`。 （如果它们的类型不同，则其中一个可以转换为另一个的类型。这里我们不考虑两者均为类型不确定值的情形。）

1. 如果`T`是一个布尔类型，则这两个值只有在它们同为`true`或者`false`的时候比较结果才为`true`。
2. 如果`T`是一个整数类型，则这两个值只有在它们在内存中的表示完全一致的情况下比较结果才为`true`。
3. 如果`T`是一个浮点数类型， 则这两个值只要满足下面任何一种情况，它们的比较结果就为`true`：
   - 它们都为`+Inf`；
   - 它们都为`-Inf`；
   - 它们都为`-0.0`或者都为`+0.0`。
   - 它们都不是`NaN`并且它们在内存中的表示完全一致。
4. 如果`T`是一个复数类型，则这两个值只有在它们的实部和虚部均做为浮点数进行进行比较的结果都为`true`的情况下比较结果才为`true`。
5. 如果`T`是一个指针类型（类型安全或者非类型安全），则这两个值只有在它们所表示的地址值相等或者它们都为nil的情况下比较结果才为`true`。
6. 如果`T`是一个通道类型，则这两个值只有在它们引用着相同的底层内部通道或者它们都为nil时比较结果才为`true`。
7. 如果`T`是一个结构体类型，则它们的相应字段将逐对进行比较。只要有一对字段不相等，这两个结构体值就不相等。
8. 如果`T`是一个数组类型，则它们的相应元素将逐对进行比较。只要有一对元素不相等，这两个结构体值就不相等。
9. 如果`T`是一个接口类型，请参阅两个接口值是如何进行比较的。
10. 如果`T`是一个字符串类型，请参阅两个字符串值是如何进行比较的。

请注意，动态类型均为同一个不可比较类型的两个接口值的比较将产生一个恐慌。比如下面的例子：

    package main

    func main() {
    	type T struct {
    		a interface{}
    		b int
    	}
    	var x interface{} = []int{}
    	var y = T{a: x}
    	var z = [3]T{{a: y}}

    	// 这三个比较均会产生一个恐慌。
    	_ = x == x
    	_ = y == y
    	_ = z == z
    }