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

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

package main

func main() {
    // 类型[]int、IntSlice和MySlice共享底层类型：[]int。
    type IntSlice []int
    type MySlice  []int
var s  = []int{}
var is = IntSlice{}
var ms = MySlice{}
var x struct{n int `foo`}
var y struct{n int `bar`}

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

// 必须使用显式转换。
is = IntSlice(ms)
ms = MySlice(is)
x = struct{n int `foo`}(y)
y = struct{n int `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
}

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
}

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
}

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 F64b = float64(I3) // 这里必须显式转换

const C1, C2 complex64 = F, I
const I5 = int(C2) // 这里必须显式转换
}

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

一个例子：

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)
}

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)
}

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
}