Go 数据类型

在 Go 语言中,所谓的 “数据类型”,说白了就是变量或表达式中 “值” 的类型。Go 是一门静态强类型语言,每一个变量都有明确的数据类型,用来决定它能存放整数、小数还是文字,以及在内存中占用多大的空间。

从整体上来看,Go 语言的数据类型主要分为以下 2 大类,如下图所示:

  • 基本数据类型:包括整数类型、浮点数类型、布尔类型、字符类型、字符串类型,以及日常开发极少用到的复数类型。
  • 复合数据类型:包括数组、切片(slice)、Map(字典)、结构体(struct)、指针、函数、接口和通道(chan)等。

Go 数据类型分类

这一节我们先重点学习最常用的基本数据类型。

Go 整数类型

在 Go 语言中,整数类型也叫做 “整型”,用来存放没有小数部分的数学整数,比如 10、-100、0 等。

按照能否表示负数,Go 语言的整数类型一般分为 “有符号整型” 和 “无符号整型” 两种。其中,有符号整型以 int 开头,可以表示正整数、负整数和 0;无符号整型以 uint(即 “unsigned”)开头,只能表示 0 和正整数。具体分类如下表所示。

Go 整数类型
类型 字节数 取值范围
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 = 1

Go 字符串类型

字符串从名字上就很好理解,就是由一串字符组成的文本。在 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 的默认零值 ""。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号