你必须掌握的Go语言数据类型！

变量声明

在 Go 语言中，通过 var 声明语句来定义一个变量

定义的时候需要指定这个变量的类型，然后再为它起个名字，并且设置好变量的初始值。

所以 var 声明一个变量的格式如下：

1
var 变量名 类型 = 表达式
1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
    var i int = 10
    fmt.Println(i)
}

其中 var i int = 10 就是定义一个类型为 int（整数）

  • 变量名为 i 的变量，它的初始值为 10。

Go 语言中定义的变量必须使用，否则无法编译通过

  • 防止定义了变量不使用，导致浪费内存的情况；

Go 语言具有类型推导功能，所以也可以不去刻意地指定变量的类型

而是让 Go 语言自己推导，比如变量 i 也可以用如下的方式声明：

1
var i = 10

这样变量 i 的类型默认是 int 类型。

你也可以一次声明多个变量，把要声明的多个变量放到一个括号中即可

如下面的代码所示：

1
2
3
4
var (
    j int= 0
    k int= 1
)

同理因为类型推导，以上多个变量声明也可以用以下代码的方式书写：

1
2
3
4
var (
    j = 0
    k = 1
)

整型

在 Go 语言中，整型分为：

  • 有符号整型：如 int、int8、int16、int32 和 int64。
  • 无符号整型：如 uint、uint8、uint16、uint32 和 uint64。

它们的差别在于，有符号整型表示的数值可以为负数、零和正数

  • 而无符号整型只能为零和正数。

除了有用位（bit）大小表示的整型外，还有 int 和 uint 这两个没有具体 bit 大小的整型

  • 它们的大小可能是 32bit，也可能是 64bit，和硬件设备 CPU 有关。

在整型中，如果能确定 int 的 bit 就选择比较明确的 int 类型

  • 因为这会让你的程序具备很好的移植性。

在 Go 语言中，还有一种字节类型 byte，它其实等价于 uint8 类型

  • 可以理解为 uint8 类型的别名，用于定义一个字节，所以字节 byte 类型也属于整型。

浮点数

浮点数就代表现实中的小数。

Go 语言提供了两种精度的浮点数

  • 分别是 float32 和 float64。

项目中最常用的是 float64

  • 因为它的精度高，浮点计算的结果相比 float32 误差会更小。
1
2
3
4
5
var f32 float32 = 2.2

var f64 float64 = 10.3456

fmt.Println("f32 is",f32,",f64 is",f64)
1
2
3
$ go run ch02/main.go

f32 is 2.2 ,f64 is 10.3456

布尔型

一个布尔型的值只有两种：

  • true 和 false，它们代表现实中的是和否。

Go 语言中的布尔型使用关键字 bool 定义。

1
2
3
4
5
var bf bool =false

var bt bool = true

fmt.Println("bf is",bf,",bt is",bt)

布尔值可以用于一元操作符 !，表示逻辑非的意思

  • 也可以用于二元操作符 &&、||，它们分别表示逻辑和、逻辑或。

字符串

Go 语言中的字符串可以表示为任意的数据

比如以下代码，在 Go 语言中，字符串通过类型 string 声明：

1
2
3
4
5
var s1 string = "Hello"

var s2 string = "世界"

fmt.Println("s1 is",s1,",s2 is",s2)

在 Go 语言中，可以通过操作符 + 把字符串连接起来，得到一个新的字符串

比如将上面的 s1 和 s2 连接起来，如下所示：

1
fmt.Println("s1+s2=",s1+s2)

字符串也可以通过 += 运算符操作。

零值

零值其实就是一个变量的默认值，在 Go 语言中，如果我们声明了一个变量，但是没有对其进行初始化

  • 那么 Go 语言会自动初始化其值为对应类型的零值。

比如数字类的零值是 0，布尔型的零值是 false，字符串的零值是 “” 空字符串等。

变量简短声明

借助类型推导，Go 语言提供了变量的简短声明 :=，结构如下：

1
变量名:=表达式

借助 Go 语言简短声明功能，变量声明就会非常简洁

比如以上示例中的变量，可以通过如下代码简短声明：

1
2
3
4
5
i:=10

bf：=false

s1:="Hello"

指针

在 Go 语言中，指针对应的是变量在内存中的存储位置

  • 也就说指针的值就是变量的内存地址。

通过 & 可以获取一个变量的地址，也就是指针。

在以下的代码中，pi 就是指向变量 i 的指针。

要想获得指针 pi 指向的变量值，通过*pi这个表达式即可。

1
2
3
pi:=&i

fmt.Println(*pi)

常量的定义

下面的示例定义了一个常量 name，它的值是飞雪无情。

因为 Go 语言可以类型推导，所以在常量声明时也可以省略类型。

1
const name =  "飞雪无情"

在 Go 语言中，只允许布尔型、字符串、数字类型这些基础类型作为常量。

iota

iota 是一个常量生成器，它可以用来初始化相似规则的常量，避免重复的初始化。

假设我们要定义 one、two、three 和 four 四个常量：

对应的值分别是 1、2、3 和 4，如果不使用 iota，则需要按照如下代码的方式定义：

1
2
3
4
5
6
const(
    one = 1
    two = 2
    three =3
    four =4
)

以上声明都要初始化，会比较烦琐，因为这些常量是有规律的（连续的数字）

所以可以使用 iota 进行声明，如下所示：

1
2
3
4
5
6
7
8
const(
    one = iota+1
    two
    three
    four
)

fmt.Println(one,two,three,four)

会发现打印的值和上面初始化的一样，也是 1、2、3、4。

iota 的初始值是 0，它的能力就是在每一个有常量声明的行后面 +1

下面分解上面的常量：

  • one=(0)+1，这时候 iota 的值为 0，经过计算后，one 的值为 1。

  • two=(0+1)+1，这时候 iota 的值会 +1，变成了 1

  • 经过计算后，two 的值为 2。

  • three=(0+1+1)+1，这时候 iota 的值会再 +1，变成了 2

  • 经过计算后，three 的值为 3。

  • four=(0+1+1+1)+1，这时候 iota 的值会继续再 +1，变成了 3

  • 经过计算后，four 的值为 4。

如果你定义更多的常量，就依次类推，其中 () 内的表达式

  • 表示 iota 自身 +1 的过程。

字符串和数字互转

Go 语言是强类型的语言，也就是说不同类型的变量是无法相互使用和计算的

这也是为了保证Go 程序的健壮性

  • 所以不同类型的变量在进行赋值或者计算前，需要先进行类型转换。
1
2
3
4
5
i2s:=strconv.Itoa(i)

s2i,err:=strconv.Atoi(i2s)

fmt.Println(i2s,s2i,err)

通过包 strconv 的 Itoa 函数可以把一个 int 类型转为 string

  • Atoi 函数则用来把 string 转为 int。

同理对于浮点数、布尔型

  • Go 语言提供了 strconv.ParseFloat、strconv.ParseBool、strconv.FormatFloat
    • 和 strconv.FormatBool 进行互转

对于数字类型之间，可以通过强制转换的方式，如以下代码所示：

1
2
3
4
5
i2f:=float64(i)

f2i:=int(f64)

fmt.Println(i2f,f2i)

这种使用方式比简单，采用类型（要转换的变量）格式即可。

采用强制转换的方式转换数字类型，可能会丢失一些精度

  • 比如浮点型转为整型时，小数点部分会全部丢失。

把变量转换为相应的类型后，就可以对相同类型的变量进行各种表达式运算和赋值了。

Strings包

它是用于处理字符串的工具包，里面有很多常用的函数，帮助我们对字符串进行操作

  • 比如查找字符串、去除字符串的空格、拆分字符串、判断字符串是否有某个前缀或者后缀等。
1
2
3
4
5
6
7
8
9
10
11
//判断s1的前缀是否是H

fmt.Println(strings.HasPrefix(s1,"H"))

//在s1中查找字符串o

fmt.Println(strings.Index(s1,"o"))

//把s1全部转为大写

fmt.Println(strings.ToUpper(s1))