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

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

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
}

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 C1, C2 complex64 = F, I

	// const F64b float64 = I3 // 这个赋值编译将失败
	const F64b = float64(I3)   // 这个编译没问题
	
	// const I5 int = C2 // 这个赋值编译将失败
	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
}

• 关于《Go语言101》 - 为什么写这本书
• 致谢

• Go语言简介 - 为什么Go语言值得学习
• Go官方工具链 - 如何编译和运行Go程序

• Go编程入门
  • 程序源代码基本元素介绍
  • 关键字和标识符
  • 基本类型和它们的字面量表示
  • 常量和变量 - 顺便介绍了类型不确定值和类型推断
  • 运算操作符 - 顺便介绍了更多的类型推断规则
  • 函数声明和调用
  • 代码包和包引入
  • 表达式、语句和简单语句
  • 基本流程控制语法
  • 协程、延迟函数调用、以及恐慌和恢复

• Go类型系统
  • Go类型系统概述 - 精通Go编程必读
  • 指针
  • 结构体
  • 值部 - 为了更容易和更深刻地理解Go中的各种值
  • 数组、切片和映射 - Go中的首要容器类型
  • 字符串
  • 函数 - 函数类型和函数值，以及变长参数个数函数
  • 通道 - Go特色的并发同步方式
  • 方法
  • 接口 - 通过包裹不同具体类型的非接口值来实现反射和多态
  • 类型内嵌 - 不同于继承的类型扩展方式
  • 非类型安全指针
  • 泛型 - 如何使用和解读组合类型
  • 反射 - reflect标准库包中提供的反射支持

• 一些专题
  • 代码断行规则
  • 更多关于延迟函数调用的知识点
  • 一些恐慌/恢复用例
  • 详解panic/recover原理 - 也解释了什么是“函数退出阶段”
  • 代码块和标识符作用域
  • 表达式估值顺序规则
  • 值复制成本
  • 边界检查消除

• 并发编程
  • 并发同步概述
  • 通道用例大全
  • 如何优雅地关闭通道
  • 其它并发同步技术 - 如何使用sync标准库包
  • 原子操作 - 如何使用sync/atomic标准库包
  • Go中的内存顺序保证
  • 一些常见并发编程错误

• 内存相关
  • 内存块
  • 关于Go值的内存布局
  • 一些可能的内存泄漏场景

• 一些总结
  • 一些简单的总结
  • 关于Go中的nil
  • 类型转换、赋值和值比较规则大全
  • Go中的一些语法/语义例外
  • Go细节101
  • Go问答101
  • Go技巧101

• 更多关于Go的知识