类型转换和断言的区别
我们知道，Go 语言中不允许隐式类型转换，也就是说
= 两边，不允许出现类型不相同的变量。类型转换、类型断言本质都是把一个类型转换成另外一个类型。不同之处在于，类型断言是对接口变量进行的操作。类型转换
对于
类型转换而言，转换前后的两个类型要相互兼容才行。类型转换的语法为：<结果类型> := <目标类型> ( <表达式> )
1
package main
2
3
import "fmt"
4
5
func main() {
6
var i int = 9
7
8
var f float64
9
f = float64(i)
10
fmt.Printf("%T, %v\n", f, f)
11
12
f = 10.8
13
a := int(f)
14
fmt.Printf("%T, %v\n", a, a)
15
16
// s := []int(i)
17
}
Copied!
上面的代码里，我定义了一个
int 型和 float64 型的变量，尝试在它们之前相互转换，结果是成功的：int 型和 float64 是相互兼容的。如果我把最后一行代码的注释去掉，编译器会报告类型不兼容的错误：
1
cannot convert i (type int) to type []int
Copied!
断言
前面说过，因为空接口
interface{} 没有定义任何函数，因此 Go 中所有类型都实现了空接口。当一个函数的形参是 interface{}，那么在函数中，需要对形参进行断言，从而得到它的真实类型。断言的语法为：
<目标类型的值>，<布尔参数> := <表达式>.( 目标类型 ) // 安全类型断言 <目标类型的值> := <表达式>.( 目标类型 ) //非安全类型断言
类型转换和类型断言有些相似，不同之处，在于类型断言是对接口进行的操作。
还是来看一个简短的例子：
1
package main
2
3
import "fmt"
4
5
type Student struct {
6
Name string
7
Age int
8
}
9
10
func main() {
11
var i interface{} = new(Student)
12
s := i.(Student)
13
14
fmt.Println(s)
15
}
Copied!
运行一下：
1
panic: interface conversion: interface {} is *main.Student, not main.Student
Copied!
直接
panic 了，这是因为 i 是 *Student 类型，并非 Student 类型，断言失败。这里直接发生了 panic，线上代码可能并不适合这样做，可以采用“安全断言”的语法：1
func main() {
2
var i interface{} = new(Student)
3
s, ok := i.(Student)
4
if ok {
5
fmt.Println(s)
6
}
7
}
Copied!
这样，即使断言失败也不会
panic。断言其实还有另一种形式，就是用在利用
switch 语句判断接口的类型。每一个 case 会被顺序地考虑。当命中一个 case 时，就会执行 case 中的语句，因此 case 语句的顺序是很重要的，因为很有可能会有多个 case 匹配的情况。代码示例如下：
1
func main() {
2
//var i interface{} = new(Student)
3
//var i interface{} = (*Student)(nil)
4
var i interface{}
5
6
fmt.Printf("%p %v\n", &i, i)
7
8
judge(i)
9
}
10
11
func judge(v interface{}) {
12
fmt.Printf("%p %v\n", &v, v)
13
14
switch v := v.(type) {
15
case nil:
16
fmt.Printf("%p %v\n", &v, v)
17
fmt.Printf("nil type[%T] %v\n", v, v)
18
19
case Student:
20
fmt.Printf("%p %v\n", &v, v)
21
fmt.Printf("Student type[%T] %v\n", v, v)
22
23
case *Student:
24
fmt.Printf("%p %v\n", &v, v)
25
fmt.Printf("*Student type[%T] %v\n", v, v)
26
27
default:
28
fmt.Printf("%p %v\n", &v, v)
29
fmt.Printf("unknow\n")
30
}
31
}
32
33
type Student struct {
34
Name string
35
Age int
36
}
Copied!
main 函数里有三行不同的声明，每次运行一行，注释另外两行，得到三组运行结果：1
// --- var i interface{} = new(Student)
2
0xc4200701b0 [Name: ], [Age: 0]
3
0xc4200701d0 [Name: ], [Age: 0]
4
0xc420080020 [Name: ], [Age: 0]
5
*Student type[*main.Student] [Name: ], [Age: 0]
6
7
// --- var i interface{} = (*Student)(nil)
8
0xc42000e1d0 <nil>
9
0xc42000e1f0 <nil>
10
0xc42000c030 <nil>
11
*Student type[*main.Student] <nil>
12
13
// --- var i interface{}
14
0xc42000e1d0 <nil>
15
0xc42000e1e0 <nil>
16
0xc42000e1f0 <nil>
17
nil type[<nil>] <nil>
Copied!
对于第一行语句：
1
var i interface{} = new(Student)
Copied!
i 是一个 *Student 类型，匹配上第三个 case，从打印的三个地址来看，这三处的变量实际上都是不一样的。在 main 函数里有一个局部变量 i；调用函数时，实际上是复制了一份参数，因此函数里又有一个变量 v，它是 i 的拷贝；断言之后，又生成了一份新的拷贝。所以最终打印的三个变量的地址都不一样。对于第二行语句：
1
var i interface{} = (*Student)(nil)
Copied!
这里想说明的其实是
i 在这里动态类型是 (*Student), 数据为 nil，它的类型并不是 nil，它与 nil 作比较的时候，得到的结果也是 false。最后一行语句：
1
var i interface{}
Copied!
这回
i 才是 nil 类型。【引申1】
fmt.Println 函数的参数是 interface。对于内置类型，函数内部会用穷举法，得出它的真实类型，然后转换为字符串打印。而对于自定义类型，首先确定该类型是否实现了 String() 方法，如果实现了，则直接打印输出 String() 方法的结果；否则，会通过反射来遍历对象的成员进行打印。再来看一个简短的例子，比较简单，不要紧张：
1
package main
2
3
import "fmt"
4
5
type Student struct {
6
Name string
7
Age int
8
}
9
10
func main() {
11
var s = Student{
12
Name: "qcrao",
13
Age: 18,
14
}
15
16
fmt.Println(s)
17
}
Copied!
因为
Student 结构体没有实现 String() 方法，所以 fmt.Println 会利用反射挨个打印成员变量：1
{qcrao 18}
Copied!
增加一个
String() 方法的实现：1
func (s Student) String() string {
2
return fmt.Sprintf("[Name: %s], [Age: %d]", s.Name, s.Age)
3
}
Copied!
打印结果：
1
[Name: qcrao], [Age: 18]
Copied!
按照我们自定义的方法来打印了。
【引申2】 针对上面的例子，如果改一下：
1
func (s *Student) String() string {
2
return fmt.Sprintf("[Name: %s], [Age: %d]", s.Name, s.Age)
3
}
Copied!
注意看两个函数的接受者类型不同，现在
Student 结构体只有一个接受者类型为 指针类型 的 String() 函数，打印结果：1
{qcrao 18}
Copied!
为什么？
类型T只有接受者是T的方法；而类型*T拥有接受者是T和*T的方法。语法上T能直接调*T的方法仅仅是Go的语法糖。
所以，
Student 结构体定义了接受者类型是值类型的 String() 方法时，通过1
fmt.Println(s)
2
fmt.Println(&s)
Copied!
均可以按照自定义的格式来打印。
如果
Student 结构体定义了接受者类型是指针类型的 String() 方法时，只有通过1
fmt.Println(&s)
Copied!
才能按照自定义的格式打印。
参考资料
Last modified 2yr ago