Go-04 Golang语言中基本数据类型之间的转换

package main

import (
	"fmt"
	"math"
	"strconv"
)

func main() {
	/*	Golang中数据类型转换
		Go 语言中只有强制类型转换，没有隐式类型转换。
		数据类型之间的转换包括：
		1. 数值类型之间的相互转换，数值类型包括整形和浮点型
			1.1 数值间转换的时候建议从小范围转换成大范围，比如int8转int16，
				大范围转换成小范围的时候，比如int16转int8，如果转换不成功就会溢出，和我们想的结果不一样
		2. 其他类型转换成String类型
		3. String类型转换成数值类型
		4. 数值类型没法和bool类型进行转换

	*/
	// 1. 数值类型之间的相互转换，数值类型包括：整形和浮点型
	// 1.1 整形间的数值运算
	var a int8 = 20
	var b int16 = 40
	var c = int16(a) + b                                      // 数值类型之间的运算，要先转换成相同类型才能运行。此处都是int16类型数值之间的相加
	fmt.Printf("整形间的数值运算,,值：%v --- 类型%T \n", c, c) // 整形间的数值运算,,值：60 --- 类型int16

	// 1.2. 浮点型之间的数值运算
	var d float32 = 3.2
	var e int16 = 6
	var f = d + float32(e)
	fmt.Printf("浮点型之间的数值运算,,值：%v --- 类型%T \n", f, f) // 浮点型之间的数值运算,,值：9.2 --- 类型float32

	// 1.3 数值类型转换建议从低位转换成高位，高位转换成低位的时候如果转换不成功就会溢出，和我们想的结果不一样。
	var a1 int16 = 129
	var b1 = int8(a1)
	fmt.Println("打印转换后b1的值： ", b1) // 打印转换后b1的值：  -127 ，这个结果和我们想要的最终结果不符合。
	// 1.4 数值之间转换小练习，计算直角三角形的斜边长，运算公式使用math包的Sqrt()函数，该函数接收的类型是float64类型的参数。
	var a2, b2 = 3, 4
	var c2 int
	// math.Sqrt()接收的参数是float64类型，需要强制转换
	c2 = int(math.Sqrt(float64(a2*a2 + b2*b2)))
	fmt.Println("直角三角形斜边长度是：", c2) // 直角三角形斜边长度是： 5

	// 2. 其他类型转换成String类型
	// 2.1 fmt.Sprintf() 把其他类型转换成String类型
	//	注意：fmt.Sprintf()使用中需要注意转换的格式，int 为%d, float 为%f, bool为%t, byte 为%c
	var ii int = 20
	var ff float64 = 12.456
	var tt bool = true
	var bb byte = 'a'
	var str1, str2, str3, str4 string
	str1 = fmt.Sprintf("%d", ii)
	str2 = fmt.Sprintf("%f", ff)
	str3 = fmt.Sprintf("%t", tt)
	str4 = fmt.Sprintf("%c", bb)
	fmt.Println(str1) // String类型的 20
	fmt.Println(str2) // String类型的 12.45600
	fmt.Println(str3) // String类型的 true
	fmt.Println(str4) // String类型的 a
	fmt.Printf("str1 type is %T, str value is %v \n", str1, str1)
	fmt.Printf("str2 type is %T, str value is %v \n", str2, str2)
	fmt.Printf("str3 type is %T, str value is %v \n", str3, str3)
	fmt.Printf("str4 type is %T, str value is %v \n", str4, str4)
	fmt.Println("****************************************")
	// 2.2 使用strconv包里面的几种转换方法进行转换
	/*	2.2 使用strconv包里面的几种转换方法进行转换
		2.2.1 int 转换成 String 类型
		2.2.2 float 转换成 String 类型
		2.2.3 bool 转换成 String 类型
		2.2.4 int64 转换成 String 类型
	*/
	// 2.2.1 int 转换成 String 类型
	var num1 int = 20
	S1 := strconv.Itoa(num1)
	fmt.Println(S1) // String类型的 20
	fmt.Printf("S1 type %T, S1=%v \n", S1, S1)
	// 2.2.2 float 转换成 String 类型
	/* 	strconv.FormatFloat(f float64, fmt byte, prec, bitSize int)
	1. 参数1是要转换的值，需要时float64类型
	2. 参数2是格式化的进制类型
		2.1 'f' (-ddd.dddd)
		2.2 'b' (-ddddp±ddd，指数为二进制)
		2.3 'e'（-d.dddde±dd，十进制指数）、
		2.4 'E'（-d.ddddE±dd，十进制指数）、
		2.5 'g' (指数很大时用'e'格式，否则'f'格式)
		2.6 'G' (指数很大时用'E'格式，否则'f'格式)
	3. 参数3是保留的小数点数量，设置为 -1 表示不对小数点格式化 ，设置为 3 表示保留三位小数。
	4. 参数4是格式化后的类型为int，位数是设置的bitSize，设置64，那就是格式化后的具体类型为int64。

	*/
	var num2 float64 = 20.113123
	S2 := strconv.FormatFloat(num2, 'f', -1, 64)
	S2_1 := strconv.FormatFloat(num2, 'f', 3, 64)
	fmt.Printf("S2 type %T, S2=%v \n", S2, S2)         // S2 type string, S1=20.113123
	fmt.Printf("S2_1 type %T, S2_1=%v \n", S2_1, S2_1) // S3 type string, S1=20.113
	// 2.2.3 bool 转 String类型
	S3 := strconv.FormatBool(true)
	fmt.Printf("S3 type %T, S3=%v \n", S3, S3)
	// 2.2.4 int64 转 String
	var num3 int64 = 20
	/*
		第二个参数为进制
	*/
	S4 := strconv.FormatInt(num3, 10) // base 这个参数表示的是进制，这里面写的是10 进制
	// S4 类型 String，值=20，将其打印出来
	fmt.Printf("S4 类型 %T，值=%v \n", S4, S4)
	// 3. String类型转换成数值类型
	// 3.1 String类型转换成int类型
	var ss = "1234"
	s, err := strconv.ParseInt(ss, 10, 64)
	if err == nil {
		fmt.Printf("String类型转成数值类型，类型是： %T, 值是： %v \n", s, s)
	}
	// 3.2 String类型转换成float类型
	strf := "3.1415926535"
	if v1, err := strconv.ParseFloat(strf, 64); err == nil {
		fmt.Printf("%T, %v \n", v1, v1) // float64, 3.1415926535
	}
	if v2, err := strconv.ParseFloat(strf, 32); err == nil {
		// 当设置bitSize为32的时候，结果依然是float64类型，鼠标放上去可以看到这个具体的用法说明，真的是太方便了，都有使用示例。
		fmt.Printf("%T, %v \n", v2, v2) // float64, 3.1415927410125732
	}
	// 3.3 String类型转换成bool类型（意义不大，纯属了解即可）
	bo, _ := strconv.ParseBool("true")      // String 类型转 bool
	fmt.Printf("类型：%T, 值：%v \n", bo, bo) // 类型：bool, 值：true
	// 4.String 转字符
	sss := "hello 张三"
	for _, v := range sss {
		fmt.Printf("%v(%c) \n", v, v)
	}

	// 5. 数值类型没法和bool类型进行转换
	// 注意：在Go语言中数值类型没法直接转换成bool类型，bool类型也没法直接转换成数值类型。

	/*	上面打印的结果全部如下所示：
		PS C:\Users\Zhaoshan.lu\go\DaDi> go run .\06.go
		整形间的数值运算,,值：60 --- 类型int16
		浮点型之间的数值运算,,值：9.2 --- 类型float32
		打印转换后b1的值：  -127
		直角三角形斜边长度是： 5
		20
		12.456000
		true
		a
		str1 type is string, str value is 20
		str2 type is string, str value is 12.456000
		str3 type is string, str value is true
		str4 type is string, str value is a
		****************************************
		20
		S1 type string, S1=20
		S2 type string, S2=20.113123
		S2_1 type string, S2_1=20.113
		float64, 3.1415927410125732
		类型：bool, 值：true
		104(h)
		101(e)
		108(l)
		108(l)
		111(o)
		32( )
		24352(张)
		19977(三)
		PS C:\Users\Zhaoshan.lu\go\DaDi>

	*/

}