3.Go基础数据类型
3.Go基础数据类型
前言
前面我们写的程序中，用到的变量的类型都是整型，但是在我们GO语言中，还有很多其它的类型，如下：
类型 | 名称 | 长度 | 零值 | 说明 |
|---|---|---|---|---|
bool | 布尔类型 | 1 | false | 其值不为真即为假，不可以用数字代表true或false |
byte | 字节型 | 1 | 0 | uint8别名 |
int, uint | 整型 | - | 0 | 有符号32位或无符号64位 |
int8 | 整型 | 1 | 0 | -128 ~ 127, |
uint8 | 整型 | 1 | 0 | 0 ~ 255 |
int16 | 整型 | 2 | 0 | -32768 ~ 32767, |
uint16 | 整型 | 2 | 0 | 0 ~ 65535 |
int32 | 整型 | 4 | 0 | -2147483648 到 2147483647 |
uint32 | 整型 | 4 | 0 | 0 到 4294967295(42亿) |
int64 | 整型 | 8 | 0 | 0 到 18446744073709551615（1844京） |
uint64 | 整型 | 8 | 0 | -9223372036854775808到 9223372036854775807 |
float32 | 浮点型 | 4 | 0.0 | 小数位精确到7位 |
float64 | 浮点型 | 8 | 0.0 | 小数位精确到15位 |
string | 字符串 | "" | utf-8字符串 |
下面我们看一下几个非常重要的类型。
1：布尔类型
在计算机中,我们用什么数据类型来表示一句话的对错，例如：在计算机中描述张三(20岁)比李四(18)小,这句话的结果？
布尔类型的变量取值要么是真（true）,要么是假(false),用bool关键字来进行定义。示例如下：
package main
import "fmt"
func main() {
//1. 声明变量，没有初始化，默认值为 false
var a bool
fmt.Println("a的默认值为:", a)
a = true // 给变量a赋值为true
fmt.Println("a赋值为: ", a)
// 2. 自动推导类型
var b = false
fmt.Println("b = ", b)
c := false
fmt.Println("c = ", c)
}
执行如下：
$ go run 01_布尔类型.go
a的默认值为: false
a赋值为: true
b = false
c = false
指定格式的输出：
package main
import "fmt"
func main() {
var b bool
b = true
fmt.Printf("b=%t",b)
}
执行如下：
$ go run 01_布尔类型_指定格式的输出.go
b=true
布尔类型主要用于后面讲解的条件判断，关于条件判断，我们在这里先举一个生活中的案例，大家可以理解一下：
2：浮点型
Go语言的浮点型：
- float32 小数位精确到7位
- float64 小数位精确到15位
package main
import "fmt"
func main() {
// 声明变量
var f1 float32
f1 = 3.141273676876876876876
fmt.Println("f1 = ", f1)
var f2 float64 // float64 比 float32 精度更高，一般开发都是使用 float64
f2 = 3.141273676876876876876
fmt.Println("f2 = ", f2)
// 自动推导类型
f3 := 3.141273676876876876876
fmt.Println("f3 = ", f3)
fmt.Printf("f3的数据类型为: %T", f3)
}
执行如下：
$ go run 02_浮点型.go
f1 = 3.1412737
f2 = 3.1412736768768768
f3 = 3.1412736768768768
f3的数据类型为: float64
有格式的输入与输出
package main
import "fmt"
func main() {
// 声明变量
var f1 float64
fmt.Println("请输入f1的值")
fmt.Scanf("%f", &f1) // 输入f1的值
fmt.Printf("f1=%f\n", f1) // 打印 f1 的值
fmt.Printf("f1=%.2f\n", f1) // 打印 f1 的值, 小数位保留2位
}
执行如下：
$ go run 02_浮点型_有格式的输入与输出.go
请输入f1的值
3.1314141414
f1=3.131414
f1=3.13
3：字符类型
（1）字符基本输入与输出
所谓字符类型是用单引号括起来的单个字符，关于字符的定义使用如下：
package main
import "fmt"
func main() {
//声明变量
var ch byte // 声明字符类型
ch = 'a' // 注意：只能使用 单引号，字符
fmt.Printf("字符ch=%c", ch) // 字符格式 %c 设置输出
}
执行如下：
字符ch=a
输入一个字符，如下所示：
package main
import "fmt"
func main() {
//声明变量
var ch byte // 声明字符类型
fmt.Println("请输入单个字符:")
fmt.Scanf("%c", &ch)
fmt.Printf("输入的字符=%c", ch) // 字符格式 %c 设置输出
}
执行如下：
请输入单个字符:
b
输入的字符=b
（2） 字符第二种输入与输出方式（通过ASCII码值输入与输出）
package main
import "fmt"
func main() {
//声明变量
var ch byte // 声明字符类型
ch = 97
fmt.Printf("输入的字符=%c", ch) // 字符格式 %c 设置输出
}
执行如下：
输入的字符=a
这里定义了，ch是一个字符类型，赋值却是一个整数97，打印的结果是小写字符’a’.
原因是：计算机不能直接存储字符类型，只能转成数字存储，但是为什么小写字符‘a’,对应的整数是97呢？
因为，计算机是根据’ASCII’码来存储，如下：
注意强调：
image-20210420075552577
问题，以下代码输出的结果是多少？
package main
import "fmt"
func main() {
//声明变量
var ch byte // 声明字符类型
ch = 'a'
fmt.Printf("输入的字符=%d\n", ch) // 设置整数格式 %d 设置输出字符，会输出什么呢？
}
答案：将会输出 ASCII码 值对应的整数，下面看看执行结果如下：
image-20210420075816161
（3） 转义字符 ：\n 换行、 \" 英文半角的双引号 、\t tab键空格、\\ 磁盘目录的路径
字符除了我们常见的字符‘a’,字符’b’等等以外，还有一些特殊的字符，例如我们讲解的’\n’, 它的作用是什么？换行，不会在屏幕上输出具体的内容。这种字符我们称为转义字符（具有特殊含义），那么除了’\n’字符以外，还有哪些是我们以后编程中经常用到的转义字符呢？
\":表示一个英文半角的双引号
func main() {
//转译字符
//1. \":表示一个英文半角的双引号
fmt.Printf("潇洒自在\"的肥子\"白")
}
执行如下：
image-20210420081303942
\t: 表示一个tab键的空格（可以用来对输出的内容进行排版）
func main() {
//转译字符
//2. \t: 表示一个tab键的空格（可以用来对输出的内容进行排版）
fmt.Printf("张三\t李四\t王五\n")
fmt.Printf("赵谦\t王晓\t赵倩\n")
}
执行如下：
image-20210420081526790
\\:表示一个\(主要用在表示磁盘目录上)
package main
import "fmt"
func main() {
//转译字符
//3. \\:表示一个\(主要用在表示磁盘目录上)
fmt.Printf("E:\\GoProject")
}
执行如下：
image-20210420081741979
以上就是我们以后编程中经常用到的转义字符.
4：字符串类型
用单引号括起来的单个字符是字符类型，用双引号括起来的字符是字符串类型。“a”是字符还是字符串呢？
下面是关于字符串的定义使用：
package main
import "fmt"
func main() {
var str1 string // 声明变量
str1 = "abc"
fmt.Println("str1 = ", str1)
fmt.Printf("str1 = %s", str1) // %s 指定输出字符串格式
}
执行如下：
image-20210420082229736
字符串输入：
package main
import "fmt"
func main() {
var str1 string // 声明变量
fmt.Printf("请输入字符串：")
fmt.Scanf("%s", &str1)
fmt.Printf("str1 = %s", str1) // %s 指定输出字符串格式
}
执行如下：
image-20210420082434174
5：字符与字符串区别
关于字符与字符串的区别：
package main
import "fmt"
func main() {
var ch byte
var str string
// 字符
// 1. 单引号
// 2. 字符，往往都只有一个字符，转移字符除外'\n'
ch = 'a'
fmt.Println("ch = ", ch)
// 字符串
// 1. 双引号
// 2. 字符串有1个或多个字符组成
// 3. 字符串都是隐藏了一个结束符, '\0'
str = "a" // 由 'a' 和 '\0' 组成一个字符串
fmt.Println("str = ", str)
str = "hello"
// 使用 len() 函数测试字符串长度
fmt.Println("str长度是:", len(str))
// 通过数组：操作字符串的某个字符，从0开始操作
fmt.Printf("str[0]=%c, str[1]=%c\n", str[0], str[1])
}
执行如下：
ch = 97
str = a
str长度是: 5
str[0]=h, str[1]=e
6：fmt输出输入
我们前面在输出与输入字符串类型，字符类型，整型等都指定了对应的格式化，那么go语言中还有哪些格式化呢？
格式 | 含义 |
|---|---|
%% | 一个%字面量 |
%b | 一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数 |
%c | 字符型。可以把输入的数字按照ASCII码相应转换为对应的字符 |
%d | 一个十进制数值(基数为10) |
%f | 以标准记数法表示的浮点数或者复数值 |
%o | 一个以八进制表示的数字(基数为8) |
%p | 以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示 |
%q | 使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字 |
%s | 字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符） |
%t | 以true或者false输出的布尔值 |
%T | 使用Go语法输出的值的类型 |
%x | 以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示 |
%X | 以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示 |
目前先掌握该表格中 %c、%d、%f、%s、%t 、%T。
其中%T 比较特别，作用是输出值的类型，示例如下：
package main
import "fmt"
func main() {
var b bool
b = true
fmt.Printf("b变量的类型是%T", b)
}
执行如下：
image-20210420083733879