数据类型介绍
Go语言中的数据类型分为:基本数据类型和复合数据类型
-
基本数据类型:整型、浮点型、布尔型、字符串
-
复合数据类型:数组、切片、结构体、函数、map、通道(channel)、接口等
基本数据类型：
整型
整型分为两个大类:
- 有符号整型按长度分为:int8、int16、int32、int64
- 对应的无符号整型:uint8、uint16、uint32、uint64
特殊整型:
// 定义int类型
var num int = 10
var number int // 默认值为0
// 转换为 int32
var b = int32(num)
浮点型
Go语音支持两种浮点型,数据格式遵循IEEE 754标准
-
float32:最大的范围约为-3.4e38~3.4e38,可以使用math.MaxFloat32定义
-
float64:最大的范围约为-1.8e308~1.8e308，可以使用math.MaxFloat64定义
-
import ( "fmt" "math" ) func main() { fmt.Println(-math.MaxFloat32) fmt.Println(math.MaxFloat32) fmt.Println(-math.MaxFloat64) fmt.Println(math.MaxFloat64) }
定义浮点型
func main() {
var a float32 = 3.12 // 占用4个字节
var b float64 = 5.12 // 占用8个字节
var c float // 默认值为0
fmt.Println(a)
fmt.Println(b)
}
格式化输出
func main() {
var a float32 = 3.123123623
fmt.Printf("%f", a) // 默认保留6位小数且四舍五入，3.123124
fmt.Printf("%.2f", a) // 默认保留2位小数且四舍五入 3.12
var fn float32 = 3.14e2 // 用科学技术法表示浮点型
fmt.Printf("%f", fn) // 314.000000
}
默认浮点类型
func main() {
// 在32位系统中，没有显示声明，则默认是float32，在64位系统中，就是float64
a := 3.1233123
fmt.Printf("%T", a)
浮点型精度丢失问题
可以使用第三方包来解决精度损失问题->： https://github.com/shopspring/decimal
布尔型
-
布尔类型变量的默认值为false
-
Go语言中不允许将整型强制转换为布尔型
-
布尔型无法参与数值运算,也无法与其他类型进行转换
var flag bool = true
var status bool // 默认值为false
字符串
声明字符串类型:
func main() {
var work string // 默认值为空
var name string = "木子" // 显示的声明字符串类型
var car = "梅赛德斯奔驰AMG GLE 53 Couple" // 根据表达式推导变量的类型
city := "Beijing" // 根据表达式推导变量的类型
fmt.Println(work)
fmt.Println(name)
fmt.Println(car)
fmt.Println(city)
}
字符串转义符
通常使用/来进行字符串的特殊符号转义
func main() {
// \n 表示换行
str1 := "this \nis str"
// C:\Go\bin 输出反斜杠
str2 := "C:\\Go\\bin"
// C:Go"bin 输出“
str3 := "C:Go\"bin"
fmt.Println(str1)
fmt.Println(str2)
fmt.Println(str3)
}
输出多行字符串
使用双引号"" 只能输出一行字符串，不能输出多行，如果要输出多行，使用反引号 ``
func main() {
str1 := `
第一行内容
第二行内容
`
fmt.Println(str1)
}
字符串的常用方法
import (
"fmt"
"strings"
)
func main() {
var str1 = "this is str"
// 输出字符串的长度
fmt.Println(len(str1))
// 拼接字符串 使用 + 号
str2 := "你好"
fmt.Println(str2 + str1)
// 拼接字符串 使用fmt.Sprintf，fmt.Sprintf的作用是格式化字符串赋值给新串
str3 := fmt.Sprintf("%v %v", str2, str1)
fmt.Println(str3)
// strings.Split,分割字符串，需要引入strings包,Split方法第一个参数是要分割的字符串，第二个参数是以什么进行分割
var str4 = "123-456-789"
arr := strings.Split(str4, "-")
fmt.Println(arr) // [123 456 789] 切片数组
// strings.Join(),把一个切片连接成一个字符串 第一个参数是要连接的数组，第二个参数是以什么连接
str5 := strings.Join(arr, "*")
fmt.Println(str5) // 123*456*789
// strings.Contains()，判断一个字符串是否包含另一个字符串,包含返回true,否则false
str6 := "this is str"
str7 := "this"
flag := strings.Contains(str6, str7)
fmt.Println(flag) // true
// strings.HasPrefix() / strings.HasSuffix() 字符串前缀、后缀判断
str8 := "this is str"
str9 := "this"
// 判断 str8的前缀是不是str9，是则是true，否则false
first := strings.HasPrefix(str8, str9)
fmt.Println(first)
// 判断str8的后缀是不是str，是则是true，否则false
last := strings.HasSuffix(str8, "str")
fmt.Println(last)
// strings.Index() / strings.LastIndex() 子串出现的位置
// 子串在str8中出现的位置,从前往后查找 查找不到返回-1
indexNum := strings.Index(str8, "is")
fmt.Println(indexNum) // 2
// 子串在str8中出现的位置,从后往前查找 查找不到返回-1
lastNum := strings.LastIndex(str8, "s")
fmt.Println(lastNum) // 8
}
byte和rune类型
组成每个字符串的元素叫做字符，可以通过遍历字符串元素获得字符，字符用单引号``包裹起来
Go语言的字符有两种：
-
uint8类型，就是byte型，代表了ascii码的一个字符
-
rune类型，代表一个utf-8字符
-
当需要处理中文、日文或者其他复合字符时，则需要用到rune类型，rune类型实际是一个int32
-
字符串中的单个字符，一个汉字占用3个字节(utf-8),一个字母占用一个字节,使用len方法的长度根据类型获取
-
Go 使用了 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理
func main() {
// golang中定义字符,字符属于int类型，对应ascii码数值
a := 'a'
b := '0'
// 当我们直接输出字符的时候，输出的是这个字符对应的ascii码的数值
fmt.Println(a) // 97
fmt.Println(b) // 48
// 原样输出字符 使用%c格式化输出 , 相应 Unicode 码点所表示的字符
fmt.Printf("%c", a) // a
}
修改字符串
要修改字符串，需要先将其转换成[]rune或者[]byte，完成后再转回为string,无论哪种转回，都会重新分配内存,并赋值字节数组
func main() {
s1 := "big"
// 1.将字符串s1 转换为byte类型
byteStr := []byte(s1)
// 2.将byte类型的第一个字符修改为p
byteStr[0] = 'p'
// 3. 将修改后的byte转回string类型
fmt.Println(string(byteStr)) // pig
// 如果字符串中有中文，转换为则需要为rune类型
s2 := "你好golang"
// 1. 将s2转为rune类型
runeStr2 := []rune(s2)
// 2. 将转换后的第一个字符修改
runeStr2[0] = '李'
// 3. 将修改后的字符转回string类型
fmt.Println(string(runeStr2))
}
数值类型之间的转换
import (
"fmt"
"strconv"
)
func main() {
/*
数值类型的转换 int、float建议从低位转换成高位，如果是高位转换低位可能会溢出
不同的数据类型不可以进行比较、运算，会报类型错误
*/
// int类型转换
var int1 int8 = 10
var int2 int16 = 20
fmt.Println(int16(int1) + int2)
// 整型和浮点型转换
var float1 float32 = 20.312
fmt.Println(float32(int2) + float1)
/* 字符串转换方式一：通过Sprintf将其他类型转换为string */
var t bool = true
var b byte = '7'
// int类型转换string
str1 := fmt.Sprintf("%d", int1)
fmt.Println(str1)
// float类型转换string
str2 := fmt.Sprintf("%f", float1)
fmt.Println(str2)
// bool转换为string
str3 := fmt.Sprintf("%t", t)
fmt.Println(str3)
// 字符转换为string
str4 := fmt.Sprintf("%c", b)
fmt.Println(str4)
/* 字符串转换方式二: 使用strconv，需要import strconv包*/
var i1 int = 20
// 数字转换字符串
s1 := strconv.FormatInt(int64(i1), 10) // 第一个参数是int64的数值,第二个参数是int类型的进制
fmt.Println(s1)
// 浮点转字符串
var f1 float32 = 20.23
s2 := strconv.FormatFloat(float64(f1), 'f', 2, 64) // Param:要转换的值、格式化类型、保留的位数、64位or32位
fmt.Println(s2)
// bool转换字符串
s3 := strconv.FormatBool(t)
fmt.Println(s3)
// 字符转换字符串
s4 := strconv.FormatUint(uint64(b), 10) // Param:unit64的数值、输出的进制
fmt.Println(s4)
/* string类型转换为数值型*/
var string1 string = "10"
// string 转换为int 返回值有两个，结果和错误
num1, _ := strconv.ParseInt(string1, 10, 64) // Param:字符串、进制、位数
fmt.Println(num1)
// string转换为float
var string2 string = "3.14"
float2, _ := strconv.ParseFloat(string2, 64) // Param:字符串、位数
fmt.Println(float2)
}