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

此篇文章将列出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开始生效。）

一个例子：

  1. package main
  3. func main() {
  4.     // 类型[]int、IntSlice和MySlice共享底层类型：[]int。
  5.     type IntSlice []int
  6.     type MySlice  []int
  8.     var s  = []int{}
  9.     var is = IntSlice{}
  10.     var ms = MySlice{}
  11.     var x struct{n int `foo`}
  12.     var y struct{n int `bar`}
  14.     // 这两行隐式转换编译不通过。
  15.     /*
  16.     is = ms
  17.     ms = is
  18.     */
  20.     // 必须使用显式转换。
  21.     is = IntSlice(ms)
  22.     ms = MySlice(is)
  23.     x = struct{n int `foo`}(y)
  24.     y = struct{n int `bar`}(x)
  26.     // 这些隐式转换是没问题的。
  27.     s = is
  28.     is = s
  29.     s = ms
  30.     ms = s
  31. }

指针相关的转换例子：

  1. package main
  3. func main() {
  4.     type MyInt int
  5.     type IntPtr *int
  6.     type MyIntPtr *MyInt
  8.     var pi = new(int)  // pi的类型为*int
  9.     var ip IntPtr = pi // 没问题，因为底层类型相同
  10.                        // 并且pi的类型为非定义类型。
  12.     // var _ *MyInt = pi // 不能隐式转换
  13.     var _ = (*MyInt)(pi) // 显式转换是没问题的
  15.     // 类型*int的值不能被直接转换为类型MyIntPtr，
  16.     // 但是可以间接地转换过去。
  17.     /*
  18.     var _ MyIntPtr = pi  // 不能隐式转换
  19.     var _ = MyIntPtr(pi) // 也不能显式转换
  20.     */
  21.     var _ MyIntPtr = (*MyInt)(pi)  // 间接隐式转换没问题
  22.     var _ = MyIntPtr((*MyInt)(pi)) // 间接显式转换没问题
  24.     // 类型IntPtr的值不能被直接转换为类型MyIntPtr，
  25.     // 但是可以间接地转换过去。
  26.     /*
  27.     var _ MyIntPtr = ip  // 不能隐式转换
  28.     var _ = MyIntPtr(ip) // 也不能显式转换
  29.     */
  30.     // 间接隐式或者显式转换都是没问题的。
  31.     var _ MyIntPtr = (*MyInt)((*int)(ip))  // ok
  32.     var _ = MyIntPtr((*MyInt)((*int)(ip))) // ok
  33. }

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

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

一个例子：

  1. package main
  3. func main() {
  4.     type C chan string
  5.     type C1 chan<- string
  6.     type C2 <-chan string
  8.     var ca C
  9.     var cb chan string
  11.     cb = ca // ok，因为底层类型相同
  12.     ca = cb // ok，因为底层类型相同
  14.     // 这4行都满足此第3条转换规则的条件。
  15.     var _, _ chan<- string = ca, cb // ok
  16.     var _, _ <-chan string = ca, cb // ok
  17.     var _ C1 = cb                   // ok
  18.     var _ C2 = cb                   // ok
  20.     // 类型C的值不能直接转换为类型C1或C2。
  21.     /*
  22.     var _ = C1(ca) // compile error
  23.     var _ = C2(ca) // compile error
  24.     */
  26.     // 但是类型C的值可以间接转换为类型C1或C2。
  27.     var _ = C1((chan<- string)(ca)) // ok
  28.     var _ = C2((<-chan string)(ca)) // ok
  29.     var _ C1 = (chan<- string)(ca)  // ok
  30.     var _ C2 = (<-chan string)(ca)  // ok
  31. }

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

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

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

给定一个动态类型为T的接口值x，x可以通过类型断言的方式x.(T)安全地转换为类型T。

给定一个接口值x和一个接口类型I，如果x的动态类型实现了接口类型I，则x可以通过类型断言的方式x.(I)安全地转换为接口类型I。

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

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

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

一个例子：

  1. package main
  3. func main() {
  4.     var _ []int = nil
  5.     var _ map[string]int = nil
  6.     var _ chan string = nil
  7.     var _ func()() = nil
  8.     var _ *bool = nil
  9.     var _ interface{} = nil
  11.     var _ int = 123.0
  12.     var _ float64 = 123
  13.     var _ int32 = 1.23e2
  14.     var _ int8 = 1 + 0i
  15. }

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

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

常量的类型转换结果一般仍然是一个常量。（除了下面第8条规则中将介绍的字符串转换为字节切片或者码点切片的情况。）

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

一个例子：

  1. package main
  3. func main() {
  4.     const I = 123
  5.     const I1, I2 int8 = 0x7F, -0x80
  6.     const I3, I4 int8 = I, 0.0
  8.     const F = 0.123456789
  9.     const F32 float32 = F
  10.     const F32b float32 = I
  11.     const F64 float64 = F
  12.     const F64b = float64(I3) // 这里必须显式转换
  14.     const C1, C2 complex64 = F, I
  15.     const I5 = int(C2) // 这里必须显式转换
  16. }

7. 非常量数值转换规则

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

非常量复数值可以被显式转换为任何复数类型。

注意，

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

一个例子：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var a, b = 1.6, -1.6 // 类型均为float64
  7.     fmt.Println(int(a), int(b)) // 1 -1
  9.     var i, j int16 = 0x7FFF, -0x8000
  10.     fmt.Println(int8(i), uint16(j)) // -1 32768
  12.     var c1 complex64 = 1 + 2i
  13.     var _ = complex128(c1)
  14. }

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

如果一个值的类型（或者默认类型）为一个整数类型，则此值可以被当作一个码点值（rune值）显式转换为任何字符串类型。

一个字符串可以被显式转换为一个字节切片类型，反之亦然。 字节切片类型是指底层类型为[]byte的类型。

一个字符串可以被显式转换为一个码点切片类型，反之亦然。 码点切片类型是指底层类型为[]rune的类型。

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

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

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

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

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

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

赋值规则

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

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

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

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

值比较规则

Go白皮书提到：

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

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

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

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

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

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

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

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

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

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

一些值比较的例子：

  1. package main
  3. // 一些类型为不可比较类型的变量。
  4. var s []int
  5. var m map[int]int
  6. var f func()()
  7. var t struct {x []int}
  8. var a [5]map[int]int
  10. func main() {
  11.     // 这些比较编译不通过。
  12.     /*
  13.     _ = s == s
  14.     _ = m == m
  15.     _ = f == f
  16.     _ = t == t
  17.     _ = a == a
  18.     _ = nil == nil
  19.     _ = s == interface{}(nil)
  20.     _ = m == interface{}(nil)
  21.     _ = f == interface{}(nil)
  22.     */
  24.     // 这些比较编译都没问题。
  25.     _ = s == nil
  26.     _ = m == nil
  27.     _ = f == nil
  28.     _ = 123 == interface{}(nil)
  29.     _ = true == interface{}(nil)
  30.     _ = "abc" == interface{}(nil)
  31. }

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

假设两个值可以相互比较，并且它们的类型同为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是一个字符串类型，请参阅两个字符串值是如何进行比较的。

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

  1. package main
  3. func main() {
  4.     type T struct {
  5.         a interface{}
  6.         b int
  7.     }
  8.     var x interface{} = []int{}
  9.     var y = T{a: x}
  10.     var z = [3]T{{a: y}}
  12.     // 这三个比较均会产生一个恐慌。
  13.     _ = x == x
  14.     _ = y == y
  15.     _ = z == z
  16. }