GO 语言的数据类型

Go 语言内置对以下这些基本数据类型的支持：

• 布尔类型：bool

• 整型：int8、byte、int16、int、uint、uintptr 等

• 浮点类型：float32、float64

• 复数类型：complex64、complex128

• 字符串：string

• 字符类型：rune

• 错误类型：error

GO 语言也支持以下复合类型：

• 指针（pointer）

• 数组（array）

• 切片（slice）

• 字典（map）

• 通道（chan）

• 结构体（struct）

• 接口（interface）

与其他静态语言相比，Go语言新增了通道类型，该类型主要用于并发编程时不同协程间的通信。

结构体类似于面向对象编程中的类（class），Go语言沿用了C语言的该语法，Go语言还把接口单独作为一个类型提取出来。

1 布尔类型

布尔类型的关键字为bool，可赋值且只可以赋值为预定义常量true和false，示例代码如下：

var v1 bool
v1 = true
v2 := (1 == 2) // v2 也会被推导为 bool 类型
fmt.Println("布尔类型初始化打印===")
fmt.Println(v1, v2)

代码运行测试

Go语言是强类型语言，变量类型一旦确定，就不能够将其他类型的值赋值给该变量，因此，布尔类型不能接受其它类型的赋值，也不支持自动或强制的类型转换。以下操作会导致Go语言的编译错误：

var b bool
b = 1
b = boo1(1)

Go 语言中，不同类型的值不能使用 == 或 != 运算符进行比较，在编译期就会报错，示例代码如下：

b := (false == 0)

在编译期报错：

2 整型和运算符

2.1 整型

整型是所有编程语言中最基础的数据类型，Go语言默认支持如下整型类型：

类型	长度（单位：字节）	说明	值范围	默认值
int8	1	带符号8位整型	-128~127	0
uint8	1	无符号8位整型，与 byte 类型等价	0~255	0
int16	2	带符号16位整型	-32768~32767	0
uint16	2	无符号16位整型	0~65535	0
int32	4	带符号32位整型，与 rune 类型等价	-2147483648~2147483647	0
uint32	4	无符号32位整型	0~4294967295	0
int64	8	带符号64位整型	-9223372036854775808~9223372036854775807	0
uint64	8	无符号64位整型	0~18446744073709551615	0
int	32位或64位	与具体平台相关	与具体平台相关	0
uint	32位或64位	与具体平台相关	与具体平台相关	0
uintptr	与对应指针相同	无符号整型，足以存储指针值的未解释位	32位平台下为4字节，64位平台下为8字节	0

Go语言针对整型类型划分较多，可以根据需要选择适合的类型以节省内存开支。

注：

• 如未注明整型的类型，Go语言默认设置

• Go语言中，这些整型都是不同的数据类型，例如 int 和 int32 在Go语言中被认为是不同的数据类型，编译器也不会自动进行类型转换，如下类似的操作就会报错：

var intValue1 int8
// Go语言会将未声明的数字默认为int类型
intValue2 := 8
intValue1 = intValue2 // 编译错误，intValue1是int8类型，intValue2是int类型

编译运行报错

使用强制类型转换可以解决这个编译错误：

var intValue1 int8
// Go语言会将未声明的数字默认为int类型
intValue2 := 8
intValue1 = int8(intValue2)

这里出现了一个错误 intValue1 declared and not used，如果出现该错误，建议在赋值语句前添加 _ 来忽略这个报错。

var intValue1 int8
intValue2 := 8 // Go语言会将未声明的数字默认为int类型
// intValue1 = intValue2       // 编译错误，intValue1是int8类型，intValue2是int类型
_ = intValue1 //忽略 declared and not used 错误
intValue1 = int8(intValue2) // 正确，将intValue2转换为int8类型
fmt.Printf("intValue1:%d, intValue2:%d\n", intValue1, intValue2)

我们还可以通过 intValue := uint8(intValue2) 这种方式同时完成类型转化和赋值操作。

2.2 运算符

2.2.1 算术运算符

GO 语言支持所有常规的整数四则运算：+、-、*、/ 和 %（取余只能用于整数），由于 GO 语言是强类型语言，不同类型的整型值不能够直接进行运算，否则会报错。

intValue3 := intValue1 + intValue2 // int + int8

intValue3 := int(intValue1) + intValue2 // 使用强类型进行转换

此外，也需要注意整型的溢出

var intValue1 int8
intValue1 = 128 // int8 可取值的范围在 -128~127

Go 语言中也支持自增/自减运算符，即 ++、--，是只能作为语句，不能作为表达式，且只能用作后缀，不能放到变量前面：

intValue1 := 10
intValue1++ // 有效，intValue1 的值变成 11
intValue1-- // 有效，intValue1 的值变成 10
intValue1 = intValue1++ // 无效，编译报错
--intValue1  // 无效，编译报错

同样支持+=、-=、*=、/=、%= 这种快捷写法：

intValue1, intValue2 := 10, 20
intValue1 += intValue2
intValue1 -= intValue2
intValue1 *= intValue2
intValue1 /= intValue2
intValue1 %= 3

2.2.2 比较运算符

Go 语言支持以下几种常见的比较运算符： >、<、==、>=、<= 和 !=，比较运算符运行的结果是布尔值。

intValue1, intValue2 := 10, 20
    if intValue1 <= intValue2 {
        fmt.Println("intValue1 <= intValue2")
    }

需要注意，不同的整型类型同样不能够使用比较运算符，但所有的比较运算都可以直接和数字进行比较。

var intValue3 int8 = 10
if intValue3 == 10 {
    fmt.Println("intValue3 == 10")
}
// 需要注意溢出的问题，这里的直接比较是编译自动进行的转换
// 编译报错：128 (untyped int constant) overflows int8
if intValue3 == 128 {
    fmt.Println("intValue3 == 128")
}

2.2.3 位运算符

Go 语言支持以下这几种位运算符：

运算符	含义	结果
x & y	按位与	把 x 和 y 都为 1 的位设为 1
x | y	按位或	把 x 或 y 为 1 的位设为 1
x ^ y	按位异或	把 x 和 y 一个为 1 一个为 0 的位设为 1
^x	按位取反	把 x 中为 0 的位设为 1，为 1 的位设为 0
x << y	左移	把 x 中的位向左移动 y 次，每次移动相当于乘以 2
x >> y	右移	把 x 中的位向右移动 y 次，每次移动相当于除以 2

位运算符代码测试：

var intValue1 uint8
var intValue2 uint8
intValue1 = 255                                            // 1111 1111
intValue2 = 0                                              // 0000 0000
fmt.Println("intValue1 & intValue2:", intValue1&intValue2) // 按位与，0
fmt.Println("intValue1 | intValue2:", intValue1|intValue2) // 按位或，255
fmt.Println("intValue1 ^ intValue2:", intValue1^intValue2) // 按位异或，255
fmt.Println("^intValue1:", ^intValue1)                     // 按位取反 0
fmt.Println("intValue1 << 1:", intValue1<<1)               // 左移1位，254
fmt.Println("intValue1 >> 1:", intValue1>>1)               // 右移1位，127

2.2.3 逻辑运算符

Go语言支持以下逻辑运算符：

运算符	含义	结果
x && y	逻辑与运算符（AND）	如果 x 和 y 都是 true，则结果为 true，否则结果为 false
x || y	逻辑或运算符（OR）	如果 x 或 y 是 true，则结果为 true，否则结果为 false
!x	逻辑非运算符（NOT）	如果 x 为 true，则结果为 false，否则结果为 true

代码运行测试：

intValue1, intValue2 := 10, 20
if intValue1 > 0 && intValue2 > 0 {
    fmt.Println("intValue1 > 0 && intValue2 > 0")
}
​
if intValue1 > 15 || intValue2 > 15 {
    fmt.Println("intValue1 > 15 || intValue2 > 15")
}
​
fmt.Println("!(intValue1 > 15):", !(intValue1 > 15))

2.2.3 运算符优先级

// 优先级自高向低进行排列
^（按位取反） !
*  /  %  <<  >>  &  &^
+  -  |  ^（按位异或）
==  !=  <  <=  >  >=
&&
||

3 浮点型与复数类型

3.1 浮点型

3.1.1 浮点型的表示

浮点型也叫浮点数，用于表示包含小数点的数据，比如 3.14、1.00 都是浮点型数据。

Go语言中的浮点数采用 IEEE-754 标准的表达式，定义了两个类型：float32 和 float64，其中float32是单精度浮点数，可以精确到小数点后7位（类似于PHP、Java等语言的float类型），float64是双精度浮点数，可以精确到小数点后15位（类似于PHP、Java等语言的double类型）。

Go语言中，定义一个浮点型变量的代码如下：

var floatValue1 float32
floatValue1 = 10
floatValue2 := 10.0 // 如果不加小数点，floatValue2 会被推导为整型而不是浮点型
floatValue3 := 1.1e-10

对于浮点类型需要被自动推导的变量，其类型将被自动设置为 float64，而不管赋值给它的数字是否是用 32 位长度表示的。因此，对于以上的例子，下面的赋值将导致编译错误：

floatValue1 = floatValue2

floatValue1 = float32(floatValue2)  // 不同浮点类型的赋值，必须要进行类型强制转换

在实际的开发中，应该尽可能地使用 float64 类型，因为 math 包中所有有关数学运算的函数都会要求接收这个类型。

3.1.2 浮点数的精度

浮点数不是一种精确的表达方式，因为二进制无法精确表示所有十进制小数，比如 0.1、0.7 这种，如下代码进行演示：

floatValue4 := 0.1
floatValue5 := 0.7
floatValue6 := floatValue4 + floatValue5 // 浮点数的操作同样严格规范类型，float32 和 float64不能够直接进行计算

0.1 + 0.7 输出结果并不是我们所想的0.8，这是因为计算机底层将十进制的 0.1 和 0.7 转化为二进制表示时，会丢失精度，因此在实践中，通常会建议避免直接比较浮点数是否相等，而是使用一个小的容忍度（epsilon）来检查它们是否足够接近。

floatValue4 := 0.1
    floatValue5 := 0.7
    floatValue6 := floatValue4 + floatValue5
​
    epsilon := 1e-10
    sum := 0.8
    if math.Abs(sum-floatValue6) < epsilon {
        fmt.Println("sum and c are approximately equal")
    } else {
        fmt.Println("sum and c are not equal")
    }

3.1.3 浮点数的比较

浮点数支持通过算术运算符进行四则运算，也支持通过比较运算符进行比较（前提是运算符两边的操作数类型一致），但是涉及到相等的比较除外，因为我们上面提到，看起来相等的两个十进制浮点数，在底层转化为二进制时会丢失精度，因此不能被表象蒙蔽。

如果一定要判断浮点数的相等，除去上面提到的精度，也可以使用 math.Dim() 方法：

floatValue1 := 0.1
floatValue2 := 0.1
p := 0.00001
// 判断 floatValue1 与 floatValue2 是否相等
if math.Dim(float64(floatValue1), floatValue2) < p {
    fmt.Println("floatValue1 和 floatValue2 相等")
}

因此判断两个浮点数是否相同，在Go语言中是通过判断两者相差的精度值，其他语言中的浮点数判断也是如此。

3.2 复数类型

除了整型和浮点型之外，Go 语言还支持复数类型，与复数相对，我们可以把整型和浮点型这种日常比较常见的数字称为实数，复数是实数的延伸，可以通过两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag），常见的表达形式如下：

z = a + bi

其中 a、b 均为实数，i 称为虚数单位，当 b = 0 时，z 就是常见的实数，当 a = 0 而 b ≠ 0 时，将 z 称之为纯虚数。

在 Go 语言中，复数支持两种类型：complex64（32 位实部和虚部） 和 complex128（64 位实部与虚部），对应的示例如下，和数学概念中的复数表示形式一致：

var complexValue1 complex64        
complexValue1 = 1.10 + 10i          // 由两个 float32 实数构成的复数类型
complexValue2 := 1.10 + 10i         // 和浮点型一样，默认自动推导的实数类型是 float64，所以 complexValue2 是 complex128 类型
complexValue3 := complex(1.10, 10)  // 与 complexValue2 等价

对于一个复数 z = complex(x, y)，就可以通过 Go 语言内置函数 real(z) 获得该复数的实部，也就是 x，通过 imag(z) 获得该复数的虚部，也就是 y。

real := real(complexValue1) // 获取复数的实部
imag := imag(complexValue1) // 获取复数的虚部

复数支持和其它数字类型一样的算术运算符。当你使用 == 或者 != 对复数进行比较运算时，由于构成复数的实数部分也是浮点型，需要注意对精度的把握。

更多关于复数的函数，请查阅 math/cmplx 标准库的文档。如果你对内存的要求不是特别高，最好使用 complex128 作为计算类型，因为相关函数大都使用这个类型的参数。

4 字符串及底层字符类型

4.1 字符串

在 Go 语言中，字符串是一种基本类型，默认是通过 UTF-8 编码的字符序列，当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节，比如中文编码通常需要 3 个字节。

4.1.1 声明和初始化：

var str string         // 声明字符串变量
str = "Hello World"    // 变量初始化
str2 := "Hello World"  // 也可以同时进行声明和初始化

也能够对这些字符串进行格式化输出：

fmt.Printf("The length of \"%s\" is %d \n", str, len(str)) 

如下表格是格式化所使用的一些参数

动词	功能
%v	按值的本来值输出
%+v	在 % v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出 % 本体
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%U	Unicode 字符
%f	浮点数
%p	指针，十六进制方式显示

虽然可以通过下标访问字符串中的字符，但是和数组不同，在Go语言中，字符串一旦初始化之后，不允许被修改。

注意，这里只是字符串中的字符不能被修改，你可以整体修改字符串。

4.1.2 转义字符

Go 语言的字符串不支持单引号，只能通过双引号定义字符串字面值，如果要对特定字符进行转义，可以通过 \ 实现，就像我们上面在字符串中转义双引号和换行符那样，常见的需要转义的字符如下所示：

• \n ：换行符

• \r ：回车符

• \t ：tab 键

• \u 或 \U ：Unicode 字符

• \\ ：反斜杠自身

此外，也可以通过如下方法在字符串中包含引号。

label := `'Search' results for "Golang":`

多行字符串，也可以通过``构建。

results := `Search results for "Golang":
    - Go
    - Golang
    - Golang Programming
    `
fmt.Println(results)

也可以使用 + 进行字符串的拼接

results = "Search results for \"Golang\":\n" +
        "- Go\n" +
        "- Golang\n" +
        "- Golang Programming\n"
fmt.Printf("%s", results)

4.1.3 字符串操作

字符串连接

Go 内置提供了丰富的字符串函数，常见的操作包含连接、获取长度和指定字符，获取长度和指定字符前面已经介绍过，字符串连接只需要通过 + 连接符即可：

str := "Hello"
str = str + ", World"
str += ", World"  // 上述语句也可以简写为这样，效果完全一样

此外，字符串可能过长，会出现换行的情况，+务必保证出现在上一行。

str = str + 
    ", World"

字符串切片

在 Go 语言中，可以通过字符串切片实现获取子串的功能。

str := "hello, world"
str1 := str[:5]  // 获取索引5（不含）之前的子串
str2 := str[7:]  // 获取索引7（含）之后的子串
str3 := str[0:5]  // 获取从索引0（含）到索引5（不含）之间的子串
fmt.Println("str1:", str1)
fmt.Println("str2:", str2)
fmt.Println("str3:", str3)

字符串遍历

Go 语言支持两种方式遍历字符串。

// 方式一：字节数组遍历
str := "Hello, 世界" 
n := len(str) 
for i := 0; i < n; i++ {
    ch := str[i]    // 依据下标取字符串中的字符，ch 类型为 byte
    fmt.Println(i, ch) 
}
// 方式二：unicode字符遍历
str := "Hello, 世界" 
for i, ch := range str { 
    fmt.Println(i, ch)    // ch 的类型为 rune 
}

可以看出，这个字符串长度为 13，尽管从直观上来说，这个字符串应该只有 9 个字符。这是因为每个中文字符在 UTF-8 中占 3 个字节，而不是 1 个字节。

这个时候，打印的就是 9 个字符了，因为以 Unicode 字符方式遍历时，每个字符的类型是 rune，而不是 byte。

这里的 rune 和 byte 也即Go语言底层字符类型。

• byte，代表 UTF-8 编码中单个字节的值（它也是 uint8 类型的别名，两者是等价的，因为正好占据 1 个字节的内存空间）；

• rune，代表单个 Unicode 字符（它也是 int32 类型的别名，因为正好占据 4 个字节的内存空间）。

5 基本数据类型之间的转化

5.1 整型之间的转化

在进行类型转化时只需要调用要转化的数据类型对应的函数即可：

v1 := uint(16)   // 初始化 v1 类型为 unit
v2 := int8(v1)   // 将 v1 转化为 int8 类型并赋值给 v2
v3 := uint16(v2) // 将 v2 转化为 uint16 类型并赋值给 v3

由高向低转换时，需要注意整数的溢出

v1 := uint(-255) // uint 是无符号整型，在编译时这里会产生溢出

v4 := int16(-255) // 这里也要注意溢出，如这里是int8(-255)就会报错

5.2 整型和浮点数之间的转化

v1 := 99.99
v2 := int(v1)  // 浮点数转化为整型，小数点后的数字直接被抛弃
​
v3 := 99
v4 := float64(v3) // 整型转化为浮点数，直接调取对应的类型即可

5.3 数值和浮点数的转换

目前 Go 语言不支持将数值类型转化为布尔型，需要自己根据需求去实现类似的转化。

5.4 字符串和其他基本类型之间的转化

5.4.1 整型转化成字符串

整型数据可以通过 Unicode 字符集转化为对应的 UTF-8 编码的字符串：

v1 := 65
v2 := string(v1)  // v2 = A
v3 := 30028
v4 := string(v3) 

5.4.2 strconv 包

Go 语言默认不支持将字符串类型强制转化为数值类型，即使字符串中包含数字也不行。

如果要实现更强大的基本数据类型与字符串之间的转化，可以使用 Go 官方 strconv 包提供的函数：

v1 := "100"
v2, _ := strconv.Atoi(v1) // 将字符串转化为整型，v2 = 100
v3 := 100
v4 := strconv.Itoa(v3) // 将整型转化为字符串, v4 = "100"
v5 := "true"
v6, _ := strconv.ParseBool(v5) // 将字符串转化为布尔型
v5 = strconv.FormatBool(v6)    // 将布尔值转化为字符串
v7 := "100"
v8, _ := strconv.ParseInt(v7, 10, 64)  // 将字符串转化为整型，第二个参数表示进制，第三个参数表示最大位数
v7 = strconv.FormatInt(v8, 10)         // 将整型转化为字符串，第二个参数表示进制
v9, _ := strconv.ParseUint(v7, 10, 64) // 将字符串转化为无符号整型，参数含义同 ParseInt
v7 = strconv.FormatUint(v9, 10)        // 将无符号整数型转化为字符串，参数含义同 FormatInt
v10 := "99.99"
v11, _ := strconv.ParseFloat(v10, 64) // 将字符串转化为浮点型，第二个参数表示精度
v10 = strconv.FormatFloat(v11, 'E', -1, 64)
q := strconv.Quote("Hello, 世界")       // 为字符串加引号
q = strconv.QuoteToASCII("Hello, 世界") // 将字符串转化为 ASCII 编码