2.4 基本数据类型
2.4 基本数据类型
基本数据类型包括：
- 整型
- 浮点型
- 布尔类型
- 字符串
以上四种数据类型在几乎所有的编程语言中都支持
2.4.1 整型
计算机基础科普
- 字节(Byte)：计算机中数据存储的单位。
- 位(bit)：也叫“比特”/“比特流”，计算机中数据存储的最小单位，因为计算机中是以二进制形式进行数据存储，所以每个位以“0”和“1”表示。
- 换算关系：8bit = 1Byte
整型类型
| 整型类型 | 取值范围 |
|---|---|
| int8 | -128~127 |
| uint8 | 0~255 |
| int16 | -32768~32767 |
| uint16 | 0~65535 |
| int32 | -2147483648~2417483647 |
| uint32 | 0~4294967295 |
| int64 | -9223372036854775808 ~ 9223372036854775807 |
| uint64 | 0 ~ 18446744073709551615 |
| int | 与平台相关，32 位操作系统上就是 uint32，64 位操作系统上就是 uint64 |
| uint | 与平台相关，32 位操作系统上就是 int32，64 位操作系统上就是 int64 |
整型进制转换示例代码
package main
import "fmt"
func main() {
fmt.Println("十进制转换")
// 十进制即正常表示的格式的数字
var a int = 10
fmt.Printf("%d \n", a)
fmt.Printf("%b \n", a)
fmt.Printf("%o \n", a)
fmt.Printf("%x \n", a)
// 二进制即以0b开头的数字
// 0b10101000 ==>10禁止168
fmt.Println("二进制转换")
var b int = 0b10101000
fmt.Printf("%d \n", b)
fmt.Printf("%b \n", b)
fmt.Printf("%o \n", b)
fmt.Printf("%x \n", b)
// 八进制即以0开头的数字
fmt.Println("八进制转换")
var c int = 020
fmt.Printf("%o \n", c)
fmt.Printf("%d \n", c)
fmt.Printf("%x \n", c)
fmt.Printf("%b \n", c)
// 十六进制即以0x开头的数字 0xff ==>256
fmt.Println("十六进制转换")
var d int = 0xff
fmt.Printf("%d \n", d)
fmt.Printf("%o \n", d)
fmt.Printf("%x \n", d)
fmt.Printf("%b \n", d)
}
2.4.2 浮点型
-
float 类型
- float32 单精度浮点数占用 4 个字节（32 位）存储空间来存储一个浮点数
- float64 双精度浮点数使用 8 个字节（64 位）存储空间来存储一个浮点数
-
两种浮点型数据格式遵循 IEEE 754 标准。
-
单精度浮点数最多有 7 位十进制有效数字，如果某个数的有效数字位数超过 7 位，当把它定义为单精度变量时，超出的部分会自动四舍五入。
-
双精度浮点数可以表示十进制的 15 或 16 位有效数字，超出的部分也会自动四舍五入
-
浮点类型默认声明为 float64。
float 类型示例代码：
package main
import (
"fmt"
"reflect"
)
func main() {
fmt.Println("float32 单精度浮点型")
var f1 float32
f1 = 3.1234567890123456789
fmt.Println(f1, reflect.TypeOf(f1))
fmt.Println("float64 双精度浮点型")
var f2 float64
f2 = 3.1234567890123456789
fmt.Println(f2, reflect.TypeOf(f2))
fmt.Println("默认 双精度浮点型")
var f3 = 3.1234567890123456789
fmt.Println(f3, reflect.TypeOf(f3))
}
科学计数法示例代码：
fmt.Println("整数用科学计数法表示，类型也为浮点型")
var sf1 = 2e10
fmt.Println(sf1, reflect.TypeOf(sf1))
//0.02
var sf2 = 2e-2
fmt.Println(sf2, reflect.TypeOf(sf2))
2.4.3 布尔类型
布尔类型是最基本数据类型之一，只有两个值：true 和 false，分别代表逻辑判断中的真和假，主要应用在条件判断中。
示例代码：
package main
import (
"fmt"
"reflect"
)
func main() {
fmt.Println("布尔bool类型只有true和false两个值，分别代表真假两种状态")
var a, b bool
a = true
b = false
fmt.Println(a, reflect.TypeOf(a))
fmt.Println(b, reflect.TypeOf(b))
fmt.Println("比较运算的结果返回一个布尔值")
fmt.Println(1 == 1)
fmt.Println(3 > 1)
fmt.Println(2 < 1)
var name = "arthur"
// name == "lyz" 的布尔值赋给b2
var b2 = name == "lyz"
fmt.Println(b2, reflect.TypeOf(b2))
}
2.4.4 字符串
- 字符串是最基本的也是最常用的数据类型，在 go 语言里是通过双引号将多个字符串联起来的一种文本数据。用于展示和使用。
- 在 go 语言里，单引号只能表示字符。
字符串的基本使用
示例代码 1
package main
import "fmt"
func main() {
var s = "hello world"
fmt.Println(s)
fmt.Println(s[2]) //取值打印出来为字符ASCII
fmt.Println(string(s[2]))
fmt.Println(s[6:9])
}
示例图示 1
- 索引从 0 开始计数
- go 语言不支持负索引
示例代码 2
- 索引取值
- 索引切片取值
- 字符串拼接
package main
import (
"fmt"
)
func main() {
var s = "hello world"
fmt.Println(s)
fmt.Println("1) 索引取值 string[index]")
a1 := s[2]
fmt.Println(string(a1))
fmt.Printf("2)字符串的切片取值string[start:end].\n取出的元素数量为: end - start,\nstart位置可以取到，end位置取不到\n")
b1 := s[2:7]
fmt.Println(b1)
b2 := s[0:] //当缺省结束位置时，表示从开始位置连续取到末尾位置
fmt.Println(b2)
b3 := s[:8] // 当缺省开始位置时，表示从0索引开头连续取到结束位置
fmt.Println(b3)
fmt.Println("3)字符串拼接")
var s1 = "Hello "
var s2 = "World!"
var s3 = s1 + s2
fmt.Println(s3)
}
转义符
- Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等
| 转义符 | 含义 |
|---|---|
| \r | 回车符(返回行首) |
| \n | 换行符(直接调到下一行的同列位置) |
| \t | 制表符 |
| ' | 单引号 |
| " | 双引号 |
| \ | 反斜线 |
示例代码
- 反斜线
- 打印 windows 平台下的文件路径
var s1 = "hi arthur\nhi，alvin"
fmt.Println(s1)
var s2 = "His name is \"rain\""
fmt.Println(s2)
var s3 = "D:\\goStudy\\go.exe"
fmt.Println(s3)
多行字符串
- Go 语言要定义一个多行字符串时，就必须使用 ` 反引号
- 反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。
示例代码
s1 := `多行第一行
多行第二行
多行第三行`
fmt.Println(s1)
字符串的常用方法
| 方法 | 介绍 |
|---|---|
| len(str) | 获取字符串长度 |
| strings.ToUpper strings.ToLower |
生成一个新的全部大写的字符串 生成一个新的全部小写的字符串 |
| strings.ReplaceAll | 生成一个新的被替换某个字符后的字符串 |
| strings.Contains | 判断是否包含 |
| strings.HasPrefix strings.HasSuffix |
前缀/后缀判断 |
| strings.Trim | 去除字符两段匹配的内容 |
| strings.Index() strings.LastIndex() |
字符串或字符出现的位置 |
| strings.Split | 将字符串按照指定的内容分割成数组 |
| strings.Join(a[]string, sep string) | join 操作，将数组按指定的内容拼接成字符串 |
示例代码
package main
import (
"fmt"
"reflect"
"strings"
)
func main() {
var s1 = "hello arthur."
fmt.Println("字符串s1的长度:", len(s1))
fmt.Println("ToUpper转大写和ToLower转小写")
s2 := strings.ToUpper("Arthur")
s3 := strings.ToLower("ALEX")
fmt.Println(s2, s3)
fmt.Println("Trim 去除字符串两端匹配的内容")
username := " arthur "
fmt.Println(len(username))
// 去除字符串左侧匹配的内容
fmt.Println(strings.TrimLeft(username, " "))
// 去除字符串右侧匹配的内容
fmt.Println(strings.TrimRight(username, " "))
//去除字符串两端的空格
fmt.Println(strings.TrimSpace(username))
//去除字符串两段匹配的内容
fmt.Println(strings.Trim(username, " "))
fmt.Println("Index LastIndex使用案例")
users := "arthur,alvin,eric，calvin"
var userIndex1 = strings.Index(users, "alvin!")
//找不到完整匹配的字符串，返回-1
fmt.Println(userIndex1)
var userIndex2 = strings.Index(users, "eric")
//找到完整匹配的字符串，返回第一个字符的索引值
fmt.Println(userIndex2)
//找到完整匹配的字符串，返回最后一个匹配的索引值，找不到完整匹配的同样返回-1
var userIndex3 = strings.LastIndex(users, "r")
fmt.Println(userIndex3)
fmt.Println(strings.LastIndex(users, "ab"))
fmt.Println(strings.LastIndex(users, "lv"))
fmt.Println("HasPrefix,HasSuffix,Contains案例,返回值均为bool")
fmt.Println(strings.HasPrefix(users, "art"))
fmt.Println(strings.HasSuffix(users, "vin"))
fmt.Println(strings.Contains(users, "eric"))
fmt.Println("split和Join使用案例")
var result1 = strings.Split(users, ",")
// Split方法返回一个string类型的数组
fmt.Println(result1, reflect.TypeOf(result1))
// 将字符串数组使用特定的拼接符号 拼接成字符串
var result2 = strings.Join(result1, "-")
fmt.Println(result2, reflect.TypeOf(result2))
}
练习
func main() {
/*
假设mysql的连接串是这么个固定格式mysql -u 用户名 -p 密码
字符串练习的假定简单练习环境，按空格Split
不处理其他格式的mysql连接串
基于字符串操作获取数组、再获取用户名和密码
*/
connString := "mysql -u root -p 121"
connString_arr := strings.Split(connString, " ")
mysqlUser := connString_arr[2]
mysqlPass := connString_arr[4]
fmt.Printf("mysql用户名是: %s\nmysql密码是: %s\n", mysqlUser, mysqlPass)
}
2.4.5 类型转换
- Go 语言中只有强类型转换，没有隐式类型转换
- 语法只能在两个类型之间支持相互转换的时候使用
示例代码
package main
import (
"fmt"
"reflect"
"strconv"
)
func main() {
fmt.Println("1)整型之间的转换")
var a int8
a = 99
var b int64 = 69
fmt.Println(int64(a), reflect.TypeOf(int64(a)))
fmt.Println(b + int64(a))
fmt.Println(float64(a), reflect.TypeOf(float64(a)))
fmt.Println("2)string与int类型的转换")
//int转string
x := strconv.Itoa(98)
fmt.Println(x, reflect.TypeOf(x))
//string转int
y, _ := strconv.Atoi("97")
fmt.Println(y, reflect.TypeOf(y))
fmt.Println("3)Parse 系列函数")
/*
ParseInt
输入：
第1个参数：数字的字符串形式
第2个参数：base，数字字符串的进制选择，比如10进制，2进制等
第3个参数：bitSize，大小限制，如果字符串转换的整型数据类型超过bitSize的最大值，
那么输出的int64为bitSize的最大值，err就会显示数据超出范围。
*/
// 如下int8 最大正整数127，1000已超范围
i1, _ := strconv.ParseInt("1000", 10, 8)
fmt.Println(i1)
i2, _ := strconv.ParseInt("1000", 10, 64)
fmt.Println(i2)
//如下float32，超出范围
f1, _ := strconv.ParseFloat("3.1415926", 32)
fmt.Println(f1, reflect.TypeOf(f1))
f2, _ := strconv.ParseFloat("3.1415926", 64)
fmt.Println(f2, reflect.TypeOf(f2))
/*
返回字符串表示的bool值
它可以接收1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；
否则返回类似如下错误：
strconv.ParseBool: parsing "Tr": invalid syntax
strconv.ParseBool: parsing "100": invalid syntax
*/
b1, _ := strconv.ParseBool("true")
fmt.Println(b1, reflect.TypeOf(b1))
b2, _ := strconv.ParseBool("T")
fmt.Println(b2, reflect.TypeOf(b2))
b3, _ := strconv.ParseBool("1")
fmt.Println(b3, reflect.TypeOf(b3))
b4, b4_err := strconv.ParseBool("100")
fmt.Println(b4, reflect.TypeOf(b4), b4_err)
b5, _ := strconv.ParseBool("0")
fmt.Println(b5, reflect.TypeOf(b5))
b6, b6_err := strconv.ParseBool("Tr")
fmt.Println(b6, reflect.TypeOf(b6), b6_err)
}
