Go 的类型系统

Go 是一门静态强类型语言，这意味着变量的类型在编译时确定且不会改变，同时编译器会严格检查类型匹配。这种设计虽然少了一些动态语言的灵活性，但换来了代码的清晰、安全和高性能。本文将梳理 Go 类型系统的主要特点。

一、静态 vs 动态，强类型 vs 弱类型

静态类型

变量一旦声明为某种类型，就只能存储该类型的值。下面的代码无法通过编译，因为 int 变量不能赋值为字符串：

复制代码

var a int = 64
a = "64"   // 错误：不能将字符串赋给 int

Go 的短变量声明 := 看起来像动态语言，但类型是由编译器根据右值推断的，推断后同样不可变。

强类型

不同类型之间不能直接运算，编译器会报错，而不是尝试隐式转换：

复制代码

fmt.Println(1 + "1")   // 错误：int 与 string 不匹配

这迫使程序员显式处理类型，避免隐藏 bug。

二、类型后置：为什么类型写在变量名后面？

C 语言中复杂的类型声明很难读懂，例如一个函数指针：

复制代码

int (*(*fp)(int (*)(int, int), int))(int, int)

Go 采用类型后置，名字在前，类型在后，从左向右读更清晰：

复制代码

f func(func(int,int) int, int) func(int, int) int

一眼就能看出 f 是一个函数类型。这种设计提升了代码的可读性。

三、声明新类型：`type`

通过 type 关键字可以基于已有类型创建新类型：

复制代码

type MyInt int64
type MyMap map[string]int

新类型与底层类型是不同的类型，不能直接混用：

复制代码

var a MyInt = 10
var b int64 = 20
// fmt.Println(a + b) // 编译错误：类型不匹配

即使底层相同（都是 int64），Go 也认为 MyInt 和 int64 是两种类型。这可以防止意外的隐式转换。

四、类型别名：只是换个名字

类型别名使用 type A = B 语法，A 和 B 完全等价：

复制代码

type Int = int
var a Int = 1
var b int = 2
fmt.Println(a + b)   // 3，可以运算

别名常用于简化复杂的类型签名：

复制代码

type TwoDMap = map[string]map[string]int

func Print(m TwoDMap) { ... }

内置的 any 就是 interface{} 的别名。

五、类型转换：显式且受限

Go 只支持显式类型转换 ，格式为 T(v)。转换是否合法取决于目标类型能否代表源类型的值。

数值类型之间可以转换，但大转小可能溢出：

复制代码

var big int32 = 512
var small int8 = int8(big)   // 512 → 0（截断）

字符串与字节切片可以转换，但会复制数据。
指针、结构体等转换有更严格的限制。

转换时注意避免歧义，加括号明确优先级：

复制代码

*Point(p)     // 等价于 *(Point(p))
(*Point)(p)   // 将 p 转换为 *Point 类型

六、类型断言：从接口中提取真实类型

当变量是接口类型时，使用类型断言判断其动态类型：

复制代码

var v any = 100
if val, ok := v.(int); ok {
    fmt.Println(val)   // 100
} else {
    fmt.Println("不是 int")
}

断言返回两个值：转换后的值和布尔标志。如果只写一个值，断言失败时会 panic。

七、类型判断：`switch x.(type)`

对于多种可能的情况，可以用 switch 配合 .(type)：

复制代码

switch v.(type) {
case int:
    fmt.Println("int")
case string:
    fmt.Println("string")
default:
    fmt.Println("其他")
}

这比一连串的 if 更简洁。

八、小结

Go 的静态强类型系统让代码更健壮，但需要程序员主动处理类型转换。
类型声明（type A B）创建新类型，类型别名（type A = B）只是换名。
类型转换必须显式写，避免隐式误用。
接口相关的类型断言和类型判断是处理动态类型的常用工具。

Go 的类型系统