在 Go 语言中,所谓的 “数据类型”,说白了就是变量或表达式中 “值” 的类型。Go 是一门静态强类型语言,每一个变量都有明确的数据类型,用来决定它能存放整数、小数还是文字,以及在内存中占用多大的空间。
从整体上来看,Go 语言的数据类型主要分为以下 2 大类,如下图所示:
- 基本数据类型:包括整数类型、浮点数类型、布尔类型、字符类型、字符串类型,以及日常开发极少用到的复数类型。
- 复合数据类型:包括数组、切片(slice)、Map(字典)、结构体(struct)、指针、函数、接口和通道(chan)等。

这一节我们先重点学习最常用的基本数据类型。
Go 整数类型
在 Go 语言中,整数类型也叫做 “整型”,用来存放没有小数部分的数学整数,比如 10、-100、0 等。
按照能否表示负数,Go 语言的整数类型一般分为 “有符号整型” 和 “无符号整型” 两种。其中,有符号整型以 int 开头,可以表示正整数、负整数和 0;无符号整型以 uint(即 “unsigned”)开头,只能表示 0 和正整数。具体分类如下表所示。
| 类型 | 字节数 | 取值范围 |
|---|---|---|
| int8 | 1 字节 | -2⁷ ~ 2⁷-1(-128 ~ 127) |
| int16 | 2 字节 | -2¹⁵ ~ 2¹⁵-1(-32768 ~ 32767) |
| int32 | 4 字节 | -2³¹ ~ 2³¹-1 |
| int64 | 8 字节 | -2⁶³ ~ 2⁶³-1 |
| uint8 | 1 字节 | 0 ~ 2⁸-1(0 ~ 255) |
| uint16 | 2 字节 | 0 ~ 2¹⁶-1(0 ~ 65535) |
| uint32 | 4 字节 | 0 ~ 2³²-1 |
| uint64 | 8 字节 | 0 ~ 2⁶⁴-1 |
| int | 4 或 8 字节 | 64 位系统占 8 字节(同 int64 范围) |
| uint | 4 或 8 字节 | 64 位系统占 8 字节(同 uint64 范围) |
可能有些小伙伴会问:“int8 占 1 个字节(8 个二进制位),能表示 2⁸ = 256 个整数,取值范围不应该是 -128 ~ 128 吗?怎么最大只到 127 呢?” 其实我们很容易把中间的 0 给漏掉了。
我们可以把数字缩小来推算一下:假如某种类型只能表示 2² = 4 个整数,同时兼顾负数和正数时,这 4 个数就是 -2、-1、0、1。由于 0 占去了一个位置,正数最大就只能到 1;同理,int8 的正数最大也就只能到 127 了。
提示: 看到上面表格里列了 10 种整数类型,小伙伴们不用慌张,不需要去死记硬背它们的取值范围。在实际开发中,绝大多数情况下我们直接使用 int 类型就可以了,它在主流的 64 位系统上占 8 个字节,取值范围与 int64 相同。
除了上面表格中的类型之外,Go 语言还有两个专门用来表示单个字符的整数别名类型:byte 与 rune(分别是 uint8 和 int32 的别名),后面我们会专门展开介绍。
在下面的示例中,为了查看 := 自动推断出的具体类型,我们会借用 fmt.Printf() 函数的 %T 占位符把类型名称打印出来,并在字符串末尾加上 \n 表示换行。
示例 1:使用整数类型
package main
import "fmt"
func main() {
var a int = -100 // 有符号整型,可存负数
var b uint = 200 // 无符号整型,只能存非负数
c := 300 // 自动推断为 int 类型
fmt.Println(a, b, c)
fmt.Printf("%T\n", c)
}运行结果如下。
-100 200 300
int分析:
变量 a 是有符号整型 int,可以存放负数 -100;变量 b 是无符号整型 uint,只能存放 0 或正整数。如果我们尝试把负数赋给 uint 变量,或者给 int8 赋一个超出 127 的值,下面这些写法在编译阶段就会直接报错。
var b uint = -10
var x int8 = 128变量 c 使用了 := 短变量声明,并没有显式写出类型。从 fmt.Printf("%T\n", c) 输出的 int 可以看出,当我们给变量赋一个普通整数时,Go 编译器默认会将它推断为 int 类型。
另外顺便提一点,哪怕在 64 位系统上 int 和 int64 占用的字节数一样,Go 编译器依然会把它们当成两种不同的类型,不能直接放在一起运算。
Go 浮点数类型
在 Go 语言中,浮点数类型也叫做 “浮点型” 或 “小数类型”,它由整数部分和小数部分组成,比如 3.14、-0.5、66.66 等。其中 float 是英文 “floating-point(浮点数)” 的缩写。
Go 语言提供了以下 2 种浮点数类型:
- float32(单精度浮点型):在内存中占用 4 个字节,有效精度约为 6 ~ 7 位十进制数字。
- float64(双精度浮点型):在内存中占用 8 个字节,有效精度约为 15 位十进制数字。
示例 2:使用浮点数类型
package main
import "fmt"
func main() {
var f1 float32 = 3.14 // 指定为 float32
f2 := 6.28 // 自动推断为 float64
fmt.Println(f1, f2)
fmt.Printf("%T\n", f2)
}运行结果如下。
3.14 6.28
float64分析:
从运行结果可以看出,当我们使用 f2 := 6.28 自动推断小数类型时,Go 编译器默认推断出来的类型是 float64。因为 float64 的精度比 float32 更高,所以在实际开发中处理小数时,我们优先选择 float64。
另外,浮点数在计算机底层采用二进制近似保存小数,有些十进制小数无法被精确表示。当我们把小数存进 float64 变量再相加时,结果就可能出现微小的精度误差:
a := 0.1
b := 0.2
fmt.Println(a + b) // 输出:0.30000000000000004需要注意的是,如果直接写 fmt.Println(0.1 + 0.2),Go 会把 0.1 和 0.2 当成无类型常量在编译阶段做高精度计算,屏幕依然会输出 0.3。但一旦把小数存进浮点变量再参与运算,底层的二进制误差就会显现出来。
注意: 平时写代码时,我们不要直接使用 == 判断两个浮点数是否相等。遇到商品价格、账户余额等不能有误差的金额数据,建议改用整数(如以 “分” 为单位)来保存。
除了整数和浮点数之外,Go 语言还提供了 complex64 和 complex128 两种复数类型。不过复数类型在日常开发中极少用到,小伙伴们简单知道有这个类型即可,不需要过多深究。
Go 布尔类型
在 Go 语言中,布尔类型使用 bool 表示,它是英文 “boolean” 的缩写。整数和浮点数的值可以有无数个,但布尔类型的值只有 2 个:true 表示 “真”,false 表示 “假”。
布尔类型最主要的用途就是记录条件判断的结果,比如配合 if 语句决定某段代码是否执行。
示例 3:使用布尔类型
package main
import "fmt"
func main() {
var isPass bool = true // 指定为 bool 类型
isFinish := false // 自动推断为 bool 类型
fmt.Println(isPass, isFinish)
fmt.Printf("%T\n", isFinish)
}运行结果如下。
true false
bool分析:
var isPass bool = true 显式声明了一个布尔变量并赋值为 true;第 2 行 isFinish := false 则由编译器自动推断为 bool 类型。
对于 Go 语言中的布尔值,小伙伴们还需要清楚以下 2 点:
true和false的所有字母必须全部小写,写成True或False都会报错。- Go 语言的布尔类型非常独立,我们不能把数字 1 或 0 当作
true或false来使用。
比如尝试把整数 1 直接赋值给 bool 变量,下面这种写法就会触发编译报错。
var isPass bool = 1Go 字符串类型
字符串从名字上就很好理解,就是由一串字符组成的文本。在 Go 语言中,字符串类型使用 string 表示,文本内容必须使用英文双引号("")括起来。里面的字符可以是 0 个,也可以是 1 个或多个;当里面没有任何字符时写作 "",称为 “空字符串”。
示例 4:使用字符串类型
package main
import "fmt"
func main() {
var s1 string = "Hello, Go" // 显式声明字符串变量
s2 := "绿叶网" // 自动推断为 string 类型
fmt.Println(s1)
fmt.Println(s2)
}运行结果如下。
Hello, Go
绿叶网分析:
上面代码定义了两个字符串变量 s1 和 s2。需要注意的是,在 Go 语言中,普通字符串只能使用英文双引号("")括起来,不能像 Python 那样使用英文单引号('')。
// 正确方式
s := "Hello"
// 错误方式
s := 'Hello'如果我们使用单引号把一串字符括起来,Go 编译器会直接报错,因为在 Go 语言中单引号是专门留给单个字符使用的。
数据类型的默认零值
前面学习变量时我们提到过,如果使用 var 声明了一个变量但没有立即赋初值,Go 编译器会自动给它赋一个默认的初始值。这个默认值就叫做该类型的 “零值(Zero Value)”,常见基本数据类型的默认零值如下表所示。
| 数据类型 | 默认零值 | 说明 |
|---|---|---|
| 整数类型(int、uint 等) | 0 | 数字 0 |
| 浮点数类型(float32、float64) | 0 | 数字 0(即 0.0) |
| 布尔类型(bool) | false | 布尔值假 |
| 字符串类型(string) | "" | 空字符串 |
下面我们通过一个示例来验证这几种基本类型的默认零值。由于空字符串 "" 里面没有任何字符,直接打印在屏幕上什么都看不见,因此示例中配合 %q 占位符把字符串外面的双引号一并打印出来。
示例 5:查看默认零值
package main
import "fmt"
func main() {
var n int // 默认零值为 0
var f float64 // 默认零值为 0
var b bool // 默认零值为 false
var s string // 默认零值为 ""
fmt.Println(n, f, b)
fmt.Printf("%q\n", s)
}运行结果如下。
0 0 false
""分析:
在这个例子中,我们声明了 4 个不同类型的变量,都没有赋初值。第 1 行打印出了 n、f、b 的默认零值,依次是 0、0 和 false。
其中,浮点数 0.0 在使用 fmt.Println() 打印时会自动省略末尾的 .0,因此显示为 0;第 2 行配合 %q 占位符,清晰打印出了字符串变量 s 的默认零值 ""。
