11. 基本数据类型

类型总览

Go 的基本数据类型分四大类：

1. 布尔型：bool
2. 整数型：int、uint 及各种位宽变体
3. 浮点型：float32、float64
4. 复数型：complex64、complex128

另外还有两个和字符相关的类型：byte（等于 uint8）和 rune（等于 int32），下下节专门讲。

布尔型

bool 只有两个值：true 和 false。

var ok bool = true
var done bool = false
flag := true  // 短声明自动推断为 bool

Go 的布尔型和其他语言有个重要区别：整数不能当布尔值用。

var count int = 0
if count {  // 报错：non-bool count used as if condition
    fmt.Println("不为零")
}

你必须显式比较：

if count != 0 {
    fmt.Println("不为零")
}

bool 的零值是 false。

整数型

Go 的整数类型比较丰富，分有符号和无符号两大类，每类有不同的位宽。

有符号整数

类型	大小	取值范围
int8	1 字节	-128 到 127
int16	2 字节	-32768 到 32767
int32	4 字节	-2147483648 到 2147483647
int64	8 字节	-9223372036854775808 到 9223372036854775807
int	平台相关（32 或 64 位）	32 位平台同 int32，64 位平台同 int64

无符号整数

类型	大小	取值范围
uint8	1 字节	0 到 255
uint16	2 字节	0 到 65535
uint32	4 字节	0 到 4294967295
uint64	8 字节	0 到 18446744073709551615
uint	平台相关	32 或 64 位

特殊整数类型

类型	用途
uintptr	存放指针地址，用于底层编程
byte	uint8 的别名，表示一个字节
rune	int32 的别名，表示一个 Unicode 码点

日常怎么选

大部分时候用 int 就行。它是平台相关的，在 64 位系统上就是 64 位，性能最好。

var count int = 100
age := 18

需要明确控制位宽时（比如网络协议、文件格式），才用 int32、int64 这些。

需要非负数时用 uint，比如数组长度、计数器。但 Go 社区通常建议优先用 int，因为 int 和 uint 混用容易出 bug。

整数溢出

Go 的整数运算不会自动检查溢出，溢出后会回绕：

var a int8 = 127
a = a + 1
fmt.Println(a)  // -128，溢出了

如果担心溢出，可以用 math/bits 包提供的函数检查，或者用 math/big 包处理大数。

浮点型

Go 有两种浮点数类型，遵循 IEEE 754 标准：

类型	大小	精度
float32	4 字节	约 6-7 位小数
float64	8 字节	约 15-16 位小数

var pi float64 = 3.141592653589793
var e float32 = 2.7182818

日常开发默认用 float64。Go 的字面量 3.14 默认就是 float64 类型。

x := 3.14  // 自动推断为 float64

fmt.Println(0.1 + 0.2 == 0.3)  // false

这是因为 0.1 和 0.2 在二进制浮点数中无法精确表示。比较浮点数要用差值小于某个阈值的方式。

复数型

Go 内置了复数类型，这在编程语言里比较少见：

类型	说明
complex64	实部和虚部都是 float32
complex128	实部和虚部都是 float64

var c1 complex64 = 3 + 4i
var c2 complex128 = complex(3.0, 4.0)

fmt.Println(c1)           // (3+4i)
fmt.Println(real(c1))     // 3（实部）
fmt.Println(imag(c1))     // 4（虚部）

real() 取实部，imag() 取虚部，complex() 构造复数。

类型的零值

回顾一下各基本类型的零值：

类型	零值
bool	false
所有整数类型	0
所有浮点类型	0.0
所有复数类型	(0+0i)

var b bool
var i int
var f float64
var c complex128

fmt.Println(b)  // false
fmt.Println(i)  // 0
fmt.Println(f)  // 0
fmt.Println(c)  // (0+0i)

字面量与类型推断

整数字面量默认推断为 int：

x := 42       // int
y := 100      // int

如果超出 int 范围（在 64 位平台上），会自动用 int64，再大就报错。

浮点数字面量默认推断为 float64：

f := 3.14     // float64

可以用类型后缀改变默认推断：

i := 42       // int
i8 := int8(42)  // 显式指定
f32 := 3.14    // float64
f32_2 := float32(3.14)  // 显式指定

查看类型

用 fmt.Printf 的 %T 动词可以查看变量类型：

func main() {
    a := 42
    b := 3.14
    c := true
    d := 'A'  // rune

    fmt.Printf("a: %T\n", a)  // a: int
    fmt.Printf("b: %T\n", b)  // b: float64
    fmt.Printf("c: %T\n", c)  // c: bool
    fmt.Printf("d: %T\n", d)  // d: int32
}

类型大小

用 unsafe.Sizeof 可以查看类型占多少字节：

func main() {
    fmt.Println("bool:", unsafe.Sizeof(true))          // 1
    fmt.Println("int:", unsafe.Sizeof(int(0)))          // 8（64位平台）
    fmt.Println("int32:", unsafe.Sizeof(int32(0)))      // 4
    fmt.Println("float64:", unsafe.Sizeof(float64(0)))  // 8
}

常见问题

int 和 int32 不能混用

var a int = 10
var b int32 = 20
c := a + b  // 报错：mismatched types int and int32

Go 没有隐式类型转换，int 和 int32 虽然在 32 位平台上大小一样，但它们是不同的类型。必须显式转换：

c := a + int(b)  // 正确

不要用 uint 做减法

var a uint = 3
var b uint = 5
c := a - b  // 不会报错，但结果是 18446744073709551614（下溢）
fmt.Println(c)

无符号整数减法下溢会得到一个巨大的正数，这是常见 bug 来源。

学完这节你能做什么

• 知道 Go 有哪些基本数据类型
• 选择合适的整数类型和浮点类型
• 理解整数溢出和浮点精度问题
• 用 %T 查看变量类型
• 避开 int/uint 混用的陷阱

下一节讲字符串。