Go常见数据类型操作以及fmt占位符

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

1. 关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位
2. 尾数部分可能丢失，造成精度损失。-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类型保存

1. 字符型存储到计算机中，需要将字符对应的码值(整数)找出来
   存储： 字符-》码值-》二进制-》存储
   读取： 二进制-》码值-》字符-》读取
2. 字符和码值的对应关系是通过字符编码表决定的(是规定好的)
3. 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.类型强转

1. Go语言不存在隐式类型转换，所有的类型转换都必须显式的声明（隐式转化就是自动转化）
2. 格式 ：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)

3. 只有相同底层类型的变量之间可以进行相互转换（如将 int16 类型转换成 int32 类型），不同底层类型的变量相互转换时会引发编译错误（如将 bool 类型转换为 int 类型）：
4. 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 查看指针

7. 数据参考类型附图