02 数据类型:你必须掌握的数据类型有哪些?
上节课的思考题是打印出自己的名字,这个作业比较简单,属于文本的替换,你只需要把我示例中的”Hello 世界”修改成自己的名字即可,比如以我的名字为例,替换为“飞雪无情”。
经过上一节课的学习,你已经对 Go 语言的程序结构有了初步了解,也准备好了相应的开发环境。
但是一个完整的项目需要更复杂的逻辑,不是简单的“Hello 世界”可相比的。这些逻辑通过变量、常量、类型、函数方法、接口、结构体组成,这节课我就将带你认识它们,让你的 Go 语言程序变得更加生动。
变量声明
变量代表可变的数据类型,也就是说,它在程序执行的过程中可能会被一次甚至多次修改。
在 Go 语言中,通过 var 声明语句来定义一个变量,定义的时候需要指定这个变量的类型,然后再为它起个名字,并且设置好变量的初始值。所以 var 声明一个变量的格式如下:
var 变量名 类型 = 表达式
现在我通过一个示例来演示如何定义一个变量,并且设置它的初始值:
- ch02/main.go
package main
import "fmt"
func main() {
var i int = 10
fmt.Println(i)
}
输出
10
go 声明方式
因为 Go 语言具有类型推导功能,所以也可以不去刻意地指定变量的类型,而是让 Go 语言自己推导,比如变量 i 也可以用如下的方式声明:
var i = 10
这样变量 i 的类型默认是 int 类型。
你也可以一次声明多个变量,把要声明的多个变量放到一个括号中即可,如下面的代码所示:
var (
j int= 0
k int= 1
)
同理因为类型推导,以上多个变量声明也可以用以下代码的方式书写:
var (
j = 0
k = 1
)
这样就更简洁了。
其实不止 int 类型,我后面介绍的 float64、bool、string 等基础类型都可以被自动推导,也就是可以省略定义类型。
基础类型
任何一门语言都有对应的基础类型,这些基础类型和现实中的事物一一对应,比如整型对应着 1、2、3、100 这些整数,浮点型对应着 1.1、3.4 这些小数等。
Go 语言也不例外,它也有自己丰富的基础类型,常用的有:整型、浮点数、布尔型和字符串,下面我就为你详细介绍。
整型
在 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 误差会更小。
下面的代码示例定义了两个变量 f32 和 f64,它们的类型分别为 float32 和 float64。
- ch02/main.go
var f32 float32 = 2.2
var f64 float64 = 10.3456
fmt.Println("f32 is", f32, ",f64 is", f64)
// 输出:f32 is 2.2 ,f64 is 10.3456
布尔型
一个布尔型的值只有两种:true 和 false,它们代表现实中的“是”和“否”。
它们的值会经常被用于一些判断中,比如 if 语句(以后的课时会详细介绍)等。Go 语言中的布尔型使用关键字 bool 定义。
下面的代码声明了两个变量,你可以自己运行,看看打印输出的结果。
var bt bool = true
var bf bool = false
fmt.Println("bt is", bt, ",bf is", bf)
// 输出:bt is true ,bf is false
字符串
Go 语言中的字符串可以表示为任意的数据,比如以下代码,在 Go 语言中,字符串通过类型 string 声明:
- ch02/main.go
var s1 string = "Hello"
var s2 string = "世界"
fmt.Println("s1 is",s1,",s2 is",s2)
在 Go 语言中,可以通过操作符 + 把字符串连接起来,得到一个新的字符串,比如将上面的 s1 和 s2 连接起来,如下所示:
fmt.Println("s1+s2=", s1+s2)
//s1+s2= Hello世界
零值
零值其实就是一个变量的默认值,在 Go 语言中,如果我们声明了一个变量,但是没有对其进行初始化,那么 Go 语言会自动初始化其值为对应类型的零值。
比如数字类的零值是 0,布尔型的零值是 false,字符串的零值是 “” 空字符串等。
通过下面的代码示例,就可以验证这些基础类型的零值:
var zi int
var zf float64
var zb bool
var zs string
fmt.Println(zi,zf,zb,zs)
变量
变量简短声明
有没有发现,上面我们演示的示例都有一个 var 关键字,但是这样写代码很烦琐。
借助类型推导,Go 语言提供了变量的简短声明 :=
,结构如下:
变量名:=表达式
借助 Go 语言简短声明功能,变量声明就会非常简洁,比如以上示例中的变量,可以通过如下代码简短声明:
i:=10
bf:=false
s1:="Hello"
在实际的项目实战中,如果你能为声明的变量初始化,那么就选择简短声明方式,这种方式也是使用最多的。
指针
在 Go 语言中,指针对应的是变量在内存中的存储位置,也就说指针的值就是变量的内存地址。
通过 &
可以获取一个变量的地址,也就是指针。
在以下的代码中,pi 就是指向变量 i 的指针。
要想获得指针 pi 指向的变量值,通过*pi这个表达式即可。尝试运行这段程序,会看到输出结果和变量 i 的值一样。
pi := &i
fmt.Println(pi) //0xc00000e1a8
fmt.Println(*pi) //10
赋值
在讲变量的时候,我说过变量是可以修改的,那么怎么修改呢?
这就是赋值语句要做的事情。最常用也是最简单的赋值语句就是 =,如下代码所示:
i = 20
fmt.Println("i的新值是",i)
这样变量 i 就被修改了,它的新值是 20。
常量
一门编程语言,有变量就有常量,Go 语言也不例外。
在程序中,常量的值是指在编译期就确定好的,一旦确定好之后就不能被修改,这样就可以防止在运行期被恶意篡改。
常量的定义
常量的定义和变量类似,只不过它的关键字是 const
。
下面的示例定义了一个常量 name,它的值是“飞雪无情”。
因为 Go 语言可以类型推导,所以在常量声明时也可以省略类型。
- ch02/main.go
const name = "飞雪无情"
在 Go 语言中,只允许布尔型、字符串、数字类型这些基础类型作为常量。
iota
iota 是一个常量生成器,它可以用来初始化相似规则的常量,避免重复的初始化。
假设我们要定义 one、two、three 和 four 四个常量,对应的值分别是 1、2、3 和 4,如果不使用 iota,则需要按照如下代码的方式定义:
const(
one = 1
two = 2
three =3
four =4
)
以上声明都要初始化,会比较烦琐,因为这些常量是有规律的(连续的数字),所以可以使用 iota 进行声明,如下所示:
const(
one = iota+1
two
three
four
)
fmt.Println(one,two,three,four)
//1 2 3 4
你自己可以运行程序,会发现打印的值和上面初始化的一样,也是 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 语言是强类型的语言,也就是说不同类型的变量是无法相互使用和计算的,这也是为了保证Go 程序的健壮性,所以不同类型的变量在进行赋值或者计算前,需要先进行类型转换。
涉及类型转换的知识点非常多,这里我先介绍这些基础类型之间的转换,更复杂的会在后面的课时介绍。
以字符串和数字互转这种最常见的情况为例,如下面的代码所示:
- ch02/main.go
i2s:=strconv.Itoa(i)
s2i,err:=strconv.Atoi(i2s)
fmt.Println(i2s,s2i,err)
//10 10 <nil>
通过包 strconv 的 Itoa 函数可以把一个 int 类型转为 string,Atoi 函数则用来把 string 转为 int。
同理对于浮点数、布尔型,Go 语言提供了 strconv.ParseFloat、strconv.ParseBool、strconv.FormatFloat 和 strconv.FormatBool 进行互转,你可以自己试试。
对于数字类型之间,可以通过强制转换的方式,如以下代码所示:
i2f:=float64(i)
f2i:=int(f64)
fmt.Println(i2f,f2i)
//10 10
这种使用方式比简单,采用“类型(要转换的变量)”格式即可。采用强制转换的方式转换数字类型,可能会丢失一些精度,比如浮点型转为整型时,小数点部分会全部丢失,你可以自己运行上述示例,验证结果。
把变量转换为相应的类型后,就可以对相同类型的变量进行各种表达式运算和赋值了。
Strings 包
讲到基础类型,尤其是字符串,不得不提 Go SDK 为我们提供的一个标准包 strings。
它是用于处理字符串的工具包,里面有很多常用的函数,帮助我们对字符串进行操作,比如查找字符串、去除字符串的空格、拆分字符串、判断字符串是否有某个前缀或者后缀等。
掌握好它,有利于我们的高效编程。
以下代码是我写的关于 strings 包的一些例子,你自己可以根据strings 文档自己写一些示例,多练习熟悉它们。
- ch02/main.go
//判断s1的前缀是否是H true
fmt.Println(strings.HasPrefix(s1, "H"))
//在s1中查找字符串o 4
fmt.Println(strings.Index(s1, "o"))
//把s1全部转为大写 hello
fmt.Println(strings.ToUpper(s1))
总结
本节课我讲解了变量、常量的声明、初始化,以及变量的简短声明,同时介绍了常用的基础类型、数字和字符串的转换以及 strings 工具包的使用,有了这些,你就可以写出功能更强大的程序。
在基础类型中,还有一个没有介绍的基础类型——复数,它不常用,就留给你来探索。
这里给你一个提示:复数是用 complex 这个内置函数创建的。
参考资料
http://learn.lianglianglee.com/%e4%b8%93%e6%a0%8f/22%20%e8%ae%b2%e9%80%9a%e5%85%b3%20Go%20%e8%af%ad%e8%a8%80-%e5%ae%8c/02%20%20%e6%95%b0%e6%8d%ae%e7%b1%bb%e5%9e%8b%ef%bc%9a%e4%bd%a0%e5%bf%85%e9%a1%bb%e6%8e%8c%e6%8f%a1%e7%9a%84%e6%95%b0%e6%8d%ae%e7%b1%bb%e5%9e%8b%e6%9c%89%e5%93%aa%e4%ba%9b%ef%bc%9f.md