Go 的类型系统

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）只是换名。

• 类型转换必须显式写，避免隐式误用。

• 接口相关的类型断言和类型判断是处理动态类型的常用工具。