1. 整型
整型数据分为两类,有符号和无符号两种类型
- 有符号: int, int8, int16, int32, int64
- 无符号: uint, uint8, uint16, uint32, uint64, byte
- 不同位数的整型区别在于能保存整型数字范围的大小;
- 有符号类型可以存储任何整数,无符号类型只能存储自然数
- int和uint的大小和系统有关,32位系统表示int32和uint32,如果是64位系统则表示int64和uint64
- byte与uint8类似,一般用来存储单个字符
- 在保证程序正确运行下,尽量使用占用空间小的数据类型
- fmt.Printf(“%T”, var_name)输出变量类型
- unsafe.Sizeof(var_name)查看变量占用字节
2. 浮点型
浮点型也就是小数类型,可以存放小数。比如6.6,-12.34
- 关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位
- 尾数部分可能丢失,造成精度损失。-123.0000901
//test code
func TestTestFloat(t *testing.T) {
fmt.Println(testFloat(-123.0000901, -123.0000901))
}
//
func testFloat(val float32, val2 float64) (float32, float64) {
return val, val2
}
//result
zero
-123.00009 -123.0000901
PASS
coverage: 100.0% of statements
ok zero/day01/model 0.241s
上述代码中可以得出:float64的精度要比float32的要准确 说明:如果我们要保存一个精度高的数,则应该选择float64
- 浮点型的存储分为三部分:符号位+指数位+尾数位,在存储过程中,精度会有丢失
- golang的浮点型默认为float64类型
- 通常情况下,应该使用float64,因为它比float32更精确
- 0.123可以简写成.123,也支持科学计数法表示:5.1234e2 等价于512.34
3. 字符与字符串
3.1 字符
Golang中没有专门的字符类型,如果要存储单个字符(字母),一般使用byte来保存。
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的,也就是说对于传统的字符串是由字符组成的,而Go的字符串不同,它是由字节组成的。
- 字符只能被单引号包裹,不能用双引号,双引号包裹的是字符串
- 当我们直接输出type值时,就是输出了对应字符的ASCII码值
- 当我们希望输出对应字符,需要使用格式化输出
- Go语言的字符使用UTF-8编码,英文字母占一个字符,汉字占三个字符
- 在Go中,字符的本质是一个整数,直接输出时,是该字符对应的UTF-8编码的码值。
- 可以直接给某个变量赋一个数字,然后按格式化输出时%c,会输出该数字对应的unicode字符
- 字符类型是可以运算的,相当于一个整数,因为它们都有对应的unicode码
//字符只能被单引号包裹,不能用双引号,双引号包裹的是字符串
var c1 byte = 'a'
var c2 byte = '0'
//当我们直接输出type值时,就是输出了对应字符的ASCII码值
// 97 -- 48
fmt.Println(c1, "--", c2)
//格式化输出 c1 = a c2 = 0
fmt.Printf("c1 = %c c2 = %c", c1, c2)
但是如果我们保存的字符大于255,比如存储汉字,这时byte类型就无法保存,此时可以使用uint或int类型保存
- 字符型存储到计算机中,需要将字符对应的码值(整数)找出来
存储: 字符-》码值-》二进制-》存储
读取: 二进制-》码值-》字符-》读取- 字符和码值的对应关系是通过字符编码表决定的(是规定好的)
- Go语言的编码都统一成了UTF-8。非常的方便,很统一,再也没有编码乱码的困扰了
3.2 字符串
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本
- 字符串一旦赋值了,就不能修改了:在Go中字符串是不可变的。
- 字符串的两种标识形式
#双引号,会识别转义字符
var str1 = "abc\nabc" //输出时会换行
//反引号,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击、输出源代码等效果
var str2 string = `abc\nabc` //输出时原样输出,不会转义
fmt.Println(str1, str2)
— 输出结果
3.3 字符串拼接
var str string = "hello " + "world" +
" zero"
str += "!"
fmt.Println(str) //hello world zero!
4.类型强转
- Go语言不存在隐式类型转换,所有的类型转换都必须显式的声明(隐式转化就是自动转化)
- 格式 :valueOfTypeB = typeB(valueOfTypeA)(类型 B 的值 = 类型 B(类型 A 的值))
var a int = 100
var b int8 = 100
// 正确写法
c1 := a + int(b) // c = 200
c2 := int8(a) + b // c = -56
// 错误写法
// c := a + b # error msg : invalid operation: a + b (mismatched types int and int8)
fmt.Println(c1, c2)
- 只有相同底层类型的变量之间可以进行相互转换(如将 int16 类型转换成 int32 类型),不同底层类型的变量相互转换时会引发编译错误(如将 bool 类型转换为 int 类型):
- String与int之间转换
//------- int => string
var a int = 100
// 非正常操作
fmt.Println(string(a)) //d
fmt.Printf("%T \n", a) //int
//1. 采用fmt.Sprintf("%d", n)
b := fmt.Sprintf("%d", a)
fmt.Println(b) //100
fmt.Printf("%T\n", b) //string
//2. 采用strconv.Itoa(n)
c := strconv.Itoa(a)
fmt.Println(c)
// 3. 采用strconv.FormatInt(int64(a), 10)
d := strconv.FormatInt(int64(a), 10) // 效率最高
fmt.Println(d)
//------- string => int
var a string = "100"
// 1. string转成int:
b, _ := strconv.Atoi(a)
fmt.Println(b)
fmt.Printf("%T \n", b) //int
// 2. string转成int64:
c, _ := strconv.ParseInt(a, 10, 64)
fmt.Println(c)
5. parse 解析
Parse 系列函数用于将字符串转换为指定类型的值,其中包括ParseBool()、ParseFloat()、ParseInt()、ParseUint()。
- ParseBool() 函数用于将字符串转换为 bool 类型的值,它只能接受 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE,其它的值均返回错误:func ParseBool(str string) (value bool, err error)
changBool1, err := strconv.ParseBool("false")
fmt.Println(changBool1, err)// false <nil>
changBool2, err := strconv.ParseBool("1")
fmt.Println(changBool2, err)//true <nil>
changBool3, err := strconv.ParseBool("T")
fmt.Println(changBool3, err)//true <nil>
changBool4, err := strconv.ParseBool("xxx")
fmt.Println(changBool4, err)//false strconv.ParseBool: parsing "xxx": invalid syntax
if err != nil {
fmt.Printf("str1: %v\n", err)
}
//字符串转化为bool型
fmt.Printf("type:%T value:%#v\n", changBool1, changBool1) //type:bool value:false
- ParseInt() 函数用于返回字符串表示的整数值(可以包含正负号)ParseUint() 函数的功能类似于 ParseInt() 函数,但ParseUint() 函数不接受正负号,用于无符号整型
//base 指定进制,取值范围是 2 到 36。如果 base 为 0,则会从字符串前置判断,“0x”是 16 进制,“0”是 8 进制,否则是 10 进制。
//bitSize 指定结果必须能无溢出赋值的整数类型,0、8、16、32、64 分别代表 int、int8、int16、int32、int64。
//返回的 err 是 *NumErr 类型的,如果语法有误,err.Error = ErrSyntax,如果结果超出类型范围 err.Error = ErrRange
//转化为整数ParseInt()
changeInt, err := strconv.ParseInt("-11", 10, 0)
fmt.Printf("type:%T value:%#v\n", changeInt, changeInt) //type:int64 value:-11
changeUint, err := strconv.ParseUint("10", 10, 0)
if err != nil {
fmt.Printf("err:%v\n", err)
}
fmt.Printf("type:%T value:%v\n", changeUint, changeUint) //type:uint64 value:10
- ParseFloat() 函数用于将一个表示浮点数的字符串转换为 float 类型 func ParseFloat(s string, bitSize int) (f float64, err error)
float1, err := strconv.ParseFloat("1.2", 10)
fmt.Println(float1, err)
fmt.Printf("type:%T value:%v\n", float1, float1)//type:float64 value:1.2
- format 格式: Format 系列函数实现了将给定类型数据格式化为字符串类型的功能,其中包括 FormatBool()、FormatInt()、FormatUint()、FormatFloat()。
- append 附加 Append 系列函数用于将指定类型转换成字符串后追加到一个切片中,其中包含 AppendBool()、AppendFloat()、AppendInt()、AppendUint()。
// 将转换为10进制的string,追加到slice中
b10 := []byte("base(10):")
b10 = strconv.AppendInt(b10, -42, 10)
fmt.Println(string(b10))
b16 := []byte("int (base 16):")
b16 = strconv.AppendInt(b16, -42, 16)
fmt.Println(string(b16))
6. Go语言fmt占位符
%T 查看类型
%v 输入相应值的默认格式
%b 查看二进制
%o 查看八进制
%d 查看十进制
%x 查看十六进制,字母形式为小写 a-f
%X 查看十六进制,字母形式为小写 A-F
%U 查看Unicode格式
%p 查看指针