学习go语言编程之数据类型

数据类型概述

Golang语言内置了如下基础数据类型：

• 布尔类型：bool
• 整型：int8，unit8，int16，uint16，int32，uint32，int64，uint64，int，uint，uintptr
• 浮点类型：float32，float64
• 复数类型：complex64，complex128
• 字符串：string
• 字符类型：rune
• 错误类型：error

同时，Golang还支持如下复合类型：

• 指针：pointer
• 数组：array
• 切片：slice
• 字典：map
• 通道：chan
• 结构体：struct
• 接口：inerface

布尔类型

布尔类型的关键字为bool，可赋值为预定义的true和false。

var v1 bool
v1 = true
v2 := (1 == 2) // v2会被推导为bool类型

注意：bool类型不能接受其他类型的赋值，不支持自动或强制类型转换。

var b bool
b = 1 // 编译报错
b = bool(1) // 编译报错

整型

Golang支持多个整型，如下表：

类型表示

在Golang中，int和int32被认为是两种不同的类型，编译器也不会自动做类型转换。

var value2 int32
value1 := 64 // 编译器自动推到为int类型
value2 = value1 // 编译报错
value2 = (int32)value1 // 明确使用强制类型转换，编译通过

数值运算

Golang支持的整数运算有：+，-，*，/，%。

比较运算

Golang支持的比较运算有：>，<，==，>=，<=，!=。
注意：两个不同类型的整型数不能直接比较：

var i int32 = 1
var j int64 = 2
if i == j { // 编译报错
    // TODO
}

但是不同类型的整型变量都可以与字面常量进行比较：

var i int32 = 1
var j int64 = 2
if i == 1 || j == 2 { // 编译通过
    // TODO
}

位运算

Golang支持的位运算如下表：

浮点型

浮点型用于表示包含小数点的数据，Golang中的浮点型采用IEEE-754标准的表达方式。

浮点数表示

Golang定义了两个浮点类型：float32，float64。

var f1 float32
f1 = 12
f2 := 12.0 // 会被自动设定为float64，如果不加小数点会被推导为int整型

浮点数比较

浮点数因为涉及精度问题，不能直接使用==来判断是否相等。
使用math包中的Fdim函数进行比较：

import "math"
math.Fdim(f1, f2) < p // f1和f2为两个浮点数，p为自定义的精度，如：0.00001

复数类型

复数有2个实数构成，一个表示实部，一个表示虚部。

复数表示

var v1 complex64
v1 = 3.2 + 12i        // 实部为3.2，虚部为12i
v2 := 3.2 + 12i       // v2为complex128类型
v3 = complex(3.2, 12) // v3结果同v2

实部与虚部

对于一个复数z = complex(x, y)，可以通过内置函数real(z)获得实部，通过imag(z)获得虚部。

字符串

声明和初始化字符串：

var str string          // 声明一个字符串变量
str = "Hello, World!"   // 为字符串变量赋值
ch := str[0]            // 取字符串得第一个字符

注意： 虽然可以通过下标访问字符串中的字符，但是字符串的内容不能在初始化之后修改。

s := "string"
s[0] = 'S'             // 编译报错

字符串操作

Golang支持的字符串操作如下表：

字符串遍历

Golang支持两种字符串遍历方式。
方式1：以字节数组遍历

str := "Hello, 世界"
n := len(str)
for i := 0; i < n; i++ {
    ch := str[i]
    fmt.Println(i, ch)
}

输出：

0 72
1 101
2 108
3 108
4 111
5 44
6 32
7 228
8 184
9 150
10 231
11 149
12 140

从输出结果看一共是13个字节，但是从直观上看应该只有9个字符，这是因为每个中文字符在UTF-8编码中占3个字节。

方式2：以Unicode字符遍历

str := "Hello, 世界"
for i, ch := range str {
    fmt.Println(i, ch)
}

输出：

0 72
1 101
2 108
3 108
4 111
5 44
6 32
7 19990
10 30028

以Unicode字符方式遍历时，每个字符的类型是rune，而不是byte，所以一共是9个字符。

字符类型

在Golang中支持两个字符类型，一个是byte（实际上是uint8的别名），代表UTF-8字符串的单个字节的值；另一个是rune，代表单个Unicode字符。

数组

数组是指一系列同一类型数据的集合。
数组的声明方法如下：

[32]byte  // 长度为32的数组，每个元素为一个字节
[2*N] struct {x, y int32} // 复杂类型数组
[1000] *float64  // 指针数组
[3][5]int  // 二维数组
[2][2][2]float64 // 等同于[2]([2][2]float64)

数组长度在定义后就不可更改，使用内置函数len()获取数组长度。

arrLen := len(arr)

元素访问

可以使用下标来访问数组中的元素，从0开始。

arr := [3]int{1, 2, 3}
for i := 0; i < len(arr); i++ {
    fmt.Println(arr[i])
}

使用关键字range遍历容器中的元素：

arr := [3]int{1, 2, 3}
for i, v := range arr {
    fmt.Println(i, v)
}

值类型

Golang中的数组是一个值类型！所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。
如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。

// 在函数中修改数组元素值，不会影响到原始数组
func modifyArr(arr [3]int)  {
	arr[0] = 10 // 修改数组元素
	fmt.Println("In modifyArr()，arr: ", arr)
}

func main() {
    arr := [3]int{1, 2, 3}
	modifyArr(arr)
	fmt.Println("In main()，arr: ", arr)
}

输出：

In modifyArr()，arr:  [10 2 3]
In main()，arr:  [1 2 3]

显然，在函数中修改数组元素的值，并未影响到原始数组。

数组切片

数组的长度在定义后就不可更改，数组是值类型，每次传递都将产生一个副本。
数组切片可以随时动态扩充存放空间，可以被随意传递而不会导致所管理的元素被重复复制。

创建数组切片

创建数组切片的方法主要有两种：基于数组和直接创建。

• 基于数组

数组切片可以基于一个已经存在的数组创建，数组切片可以只使用数组的一部分元素或者整个数组来创建，甚至可以创建一个比所基于的数组还要大的数组切片。

// 先定义一个数组
var arr [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

// 基于数组创建一个切片
var arrSlice []int = arr[:5]

fmt.Println(arr)
fmt.Println(arrSlice)

输出：

[1 2 3 4 5 6 7 8 9 10]
[1 2 3 4 5]

Golang支持使用arr[start:end]这种方式来基于数组生成一个数组切片，而且这种用法还非常灵活。
如下语法都是正确的：

var arrSlice1 []int = arr[:]  // 基于数组所有元素创建数组切片
var arrSlice2 []int = arr[:5] // 基于数组的前5个元素创建数组切片
var arrSlice3 []int = arr[5:] // 基于从第5个元素开始的所有元素创建数组切片

• 直接创建

使用内置函数make()可以灵活地创建数组切片。

// 创建一个初始元素个数为5的数组切片，元素初始值都为0
arrSlice1 := make([]int, 5)
fmt.Println(arrSlice1, len(arrSlice1), cap(arrSlice1))

// 创建一个初始元素个数为5的数组切片，元素初始值都为0，并预留10个元素的存储空间
arrSlice2 := make([]int, 5, 10)
fmt.Println(arrSlice2, len(arrSlice2), cap(arrSlice2))

// 直接创建并初始化包含5个元素的数组切片
arrSlice3 := []int{1, 2, 3, 4, 5}
fmt.Println(arrSlice3, len(arrSlice3), cap(arrSlice3))

以上示例中，有意思的是arrSlice1和arrSlice2的长度一样，但是存储空间却不同：arrSlice1的长度和存储空间都是5，而arrSlice2得长度为5（表示当前存储5个元素），存储空间却是10（表示最大可以存储10个元素）。

• 基于数组切片

类似于数组切片可以基于一个数组创建，数组切片也可以基于另一个数组切片创建。

oldSlice := []int{1, 2, 3, 4, 5}
newSlice := oldSlice[:3] // 基于oldSlice的前三个元素创建新的数组切片
fmt.Println(newSlice)    // [1 2 3]

有意思的是，如上示例中选择的oldSlice元素范围甚至可以超过所包含的元素个数，比如newSlice可以基于oldSlice的前6个元素创建，虽然oldSlice只包含5个元素。只要这个选择的范围不超过oldSlice存储能力（即cap()返回的值），那么这个创建程序就是合法的。newSlice中超出oldSlice元素的部分都会填上0。

// 创建一个初始容量为5，最大空间为10的数组切片
oldSlice := make([]int, 5, 10)
for i := 0; i < len(oldSlice); i++ {
    oldSlice[i] = i + 1
}
fmt.Println("oldSlice:", oldSlice)

// 选择的元素范围超过了oldSlice的元素个数5，但是小于其最大空间10
newSlice := oldSlice[:6]
// newSlice超出oldSlice元素的部分都会设置为0
fmt.Println("newSlice:", newSlice)

输出：

oldSlice: [1 2 3 4 5]
newSlice: [1 2 3 4 5 0]

元素遍历

操作数组元素的所有方法都适用于数组切片。

arrSlice := []int{1, 2, 3, 4, 5}
// 使用下表访问数组切片元素
for i := 0; i < len(arrSlice); i++ {
    fmt.Print(arrSlice[i], " ")
}
fmt.Println()
// 使用range关键字访问数组切片元素
for _, v := range arrSlice {
    fmt.Print(v, " ")
}
fmt.Println()

动态增减元素

使用内置函数append()给数组切片动态增加元素。

arrSlice := make([]int, 5)
fmt.Println(arrSlice)
arrSlice = append(arrSlice, 1) // 使用append()函数动态添加元素之后生成一个新的数组切片
fmt.Println(arrSlice)

输出：

[0 0 0 0 0]    # 在增加元素之前，数组切面元素为初始化的5个
[0 0 0 0 0 1]  # 动态增加一个元素

函数append()的第二个参数其实是一个不定参数，可以按需求添加若干个元素，甚至直接将一个数组切片追加到另一个数组切片的末尾。

arrSlice := make([]int, 5)
fmt.Println(arrSlice)
arrSlice2 := []int{1,2,3}
arrSlice = append(arrSlice, arrSlice2...) // 将arrSlice2追加到arrSlice的末尾，第二个参数后面的三个省略号非常重要
fmt.Println(arrSlice)

输出：

[0 0 0 0 0]
[0 0 0 0 0 1 2 3]

数组切片会自动处理存储空间不足的问题，如果追加的内容长度超过当前已分配的存储空间（即cap()函数值大小），数组切片会自动分配一块足够大的内存。

内容复制

使用内置函数copy()可以将内容从一个数组切片复制到另一个数组切片。
如果两个数组切片不一样大，按其中较小的那个数组切片的元素个数进行复制。

arrSlice1 := []int{1, 2, 3, 4, 5, 6}
arrSlice2 := []int{7, 8, 9}
fmt.Println("Before Copy，arrSlice1:", arrSlice1)
copy(arrSlice1, arrSlice2) // 复制arrSlice2中的全部元素到arrSlice1的前三个位置
fmt.Println("After Copy，arrSlice1:", arrSlice1)

输出：

Before Copy，arrSlice1: [1 2 3 4 5 6]
After Copy，arrSlice1: [7 8 9 4 5 6]  # 复制后arrSlice1的前三个元素被arrSlice2的三个元素替换

arrSlice1 := []int{1, 2, 3, 4, 5, 6}
arrSlice2 := []int{7, 8, 9}
fmt.Println("Before Copy，arrSlice2:", arrSlice2)
copy(arrSlice2, arrSlice1) // 复制arrSlice1的前3个元素到arrSlice2中替换替换掉原来的三个元素
fmt.Println("After Copy，arrSlice2:", arrSlice2)

输出：

Before Copy，arrSlice2: [7 8 9]
After Copy，arrSlice2: [1 2 3] # 只复制了arrSlice1的前三个元素到arrSlice2中并替换掉原来的三个元素

字典

字典map是一堆键值对的未排序集合。
假设存在一个自定义数据结构PersonInfo，定义如下：

// 自定义数据结构
type PersonInfo struct {
	ID string
	Name string
	Address string
}

变量声明

// 定义一个键类型为string，值类型为PersonInfo的字典变量
// myMap是声明的map变量名，string是键的类型，PersonInfo则是其中所存放的值类型
var myMap map[string] PersonInfo

创建

使用内置函数make()创建一个新的map。

myMap = make(map[string] PersonInfo)

也可以选择是否在创建时指定该map的初始存储能力：

// 创建一个初始大小为100的map
myMap = make(map[string] PersonInfo, 100)

还可以在创建map的时候进行初始化：

myMap := map[string] PersonInfo {
    "12345": {"12345", "zhangsan", "beijing"},
}

元素赋值

// 网map中添加元素
personDB["1235"] = PersonInfo{"12345", "zhangsan", "beijing"}

元素删除

使用内置函数delete()删除map元素：

delete(myMap, "12345")

元素查找

value, ok := myMap["12345"]
if ok {
    // 找到元素了
} else {
    // 元素未找到
}

本栏目推荐文章
• 【C语言】
• 【C语言】形参和实参的一些注意点
• Go 语言为什么不支持并发读写 map？
• Jmeter 如何连接mysql数据库？
• 函数的参数类型
• SQL Server 检测是不是数字型数据的两种方法
• 【C语言】函数的递归调用
• 如何通过Navicat把MySQL远程数据库导入到本地数据库
• 和利时MACS6通过dat文件实现任意时间范围与测点的历史数据提取与科研分析
• 深入理解spring框架：剖析多线程模式下数据库连接

语言编程 语言 类型 数据语言 类型 数据 语言 类型 数据 静态 语言 类型 格式 数据 考点 语言 类型 数据 范围 语言 类型 数据 语言 类型 数据adt 语言编程 语言 类型 数据 语言 类型 变量 语言 类型 语言程序 错误 语言 类型