go语言中基本数据类型的转换

int类型：不同类型不能够相加

package main
import (
	"fmt"
)
// 入口函数
func main()  {
	var num1 int8 = 10
	var num2 int16 = 20
	// 相加会报错
	// tempCodeRunnerFile.go:10:6: expected 'package', found 'EOF'
	fmt.Println(num1 + num2)
}

解决办法：转换为相同的类型

package main
import (
	"fmt"
)
// 入口函数
func main()  {
	var num1 int8 = 10
	var num2 int16 = 20
	// 转化为相同的类型就可以相加了
	fmt.Println(int16(num1) + num2)
	fmt.Println(num1 + int8(num2))
}

int和float类型之间的转换

package main
import (
	"fmt"
)
// 入口函数
func main()  {
	var num1 int8 = 10
	var num2 float32 = 20.12
	// 将int8转换为float32类型；他们类型一样后，再相加
	fmt.Println(float32(num1) + num2)
}

转换的注意点

注意:转换的时候建议从低位转换成高位(int8 -> int16 -> float32 -> float64)

高位转换成低位的时候如果转换不成功就会溢出，出现精度丢失的问题

其他类型转化为string 类型：fmt.Sprintf("%d",num1)

package main
import (
	"fmt"
)
// 入口函数
func main()  {
	var num1 int8 = 10
	// 将数字转化为字符串(整数类型)
	str1 := fmt.Sprintf("%d",num1)
	fmt.Printf("值:%v,类型：%T", str1, str1)
}

%d

在Go语言的fmt包中，%d 是一个格式占位符，它的含义是：

将整数类型（int、int8、int16、uint 等）格式化为十进制（基数为 10）的数字字符串。

因此可以用它来将整数转化为字符串

浮点数转换为字符串

package main
import ("fmt")
// 入口函数
func main()  {
	var num  = 30.345
  var str2  = fmt.Sprintf("%f", num)
  fmt.Printf("值：%v, 类型：%T", str2, str2) 
  // 输出 值：30.345000, 类型：string
}

转化为字符串如何保留2，3位小数

为啥现在是30.345000，而不是 30.345

布尔类型转换为字符串

package main
import ("fmt")
// 入口函数
func main()  {
	var flag = true
  var str2  = fmt.Sprintf("%t", flag)
  fmt.Printf("值：%v, 类型：%T", str2, str2) 
  // 输出： 值：true, 类型：string
}

字符转化为字符串

package main
import ("fmt")
// 入口函数
func main()  {
	var charByte = 'a'
  var str2  = fmt.Sprintf("%c", charByte)
  fmt.Printf("值：%v, 类型：%T", str2, str2) 
  // 值：a, 类型：string
}

通过包进行转换： 数字转换位字符串

strconv.FormatInt(被转化的数字,这个数字是多少位的)

被转化的数字：要求是int64的，如果不是我们手动转换为int64

package main
import ("fmt")
import ("strconv")
// 入口函数
func main()  {
	var num int = 200
  var str2  = strconv.FormatInt(int64(num), 10)
  fmt.Printf("值：%v, 类型：%T", str2, str2)
  // 值：20.59, 类型：string
}

浮点类型转换为字符串

func FormatFloat(float64, fmt byte, prec int, bitSize int) string

float64含义：你要转换的那个浮点数,必须是 float64 类型.

fmt (byte) ------ 格式标记（决定长什么样）;

'f' 十进制小数（最常用）

'e' 科学计数法（小写 e）

'E' 科学计数法（大写 E）

'b' 二进制指数（极少用，用于调试）

prec (int) ------ 精度控制（管几位数）

例：prec = 2 → 保留两位小数。

例：prec = -1 → 去掉末尾多余的 0（显示最简形式）

bitSize (int) ------ 原始精度标识（填 32 或 64）

含义：告诉函数，你原来的浮点数是用 float32 还是 float64 定义的

优先填写64

package main
import ("fmt")
import ("strconv")
// 入口函数
func main()  {
	var num  = 20.589
	// num 这个数字本身就是浮点类型，因此不需要再转换了。 f以十进制。 2表示保留2位小数，原来是64位。
	var str2 = strconv.FormatFloat(num, 'f', 2, 64)
	fmt.Printf("值：%v, 类型：%T", str2, str2)
	//  值：20.59, 类型：string
}

布尔类型转换为字符串类型

package main
import ("fmt")
import ("strconv")
// 入口函数
func main()  {
	var flag  = true
  // 布尔类型转换位字符串类型
  var str2  = strconv.FormatBool(flag)
  fmt.Printf("值：%v, 类型：%T", str2, str2)
  // 值：true, 类型：string
}

把字符串转换为整数类型

strconv.ParseInt(a, 10, 64)

参数a：需要转换的字符串

参数10:转换为10进制

参数64：转换为整数64位数还是多少位数；有64 32

它的返回值使用2个变量来接收，因为有可能来处理错误：

再次说明：必须用两个变量接收

package main
import ("fmt")
import ("strconv")
// 入口函数
func main()  {
  str  := "1246"
  // 把字符串转换为整数类型, _表示匿名变量，我们现在暂时不需要打印输出它
  num, _ := strconv.ParseInt(str, 10, 64)

  fmt.Printf("值：%v, 类型：%T", num, num)
}

把字符串转换为浮点类型

strconv.ParseFloat(a, 64)

参数a：需要转换的字符串

参数64：转换为浮点类型是64位数；

package main
import ("fmt")
import ("strconv")
// 入口函数
func main()  {
  str := "1246.456"
  // 把字符串转换为浮点类型, _表示匿名变量，我们现在暂时不需要打印输出它
  num, _ := strconv.ParseFloat(str, 64)
  fmt.Printf("值：%v, 类型：%T", num, num)
}

数值类型没法和bool 类型进行转换

注意:在go语言中，数值类型没法直接转换成bool类型 bool类型也没法直接转换成数值类型。

不建议把string类型转换为bool类型，意义不大

package main
import ("fmt")
import ("strconv")
// 入口函数
func main()  {
	var str  = "xxxx"
  boolValue, _ := strconv.ParseBool(str)
  fmt.Printf("值：%v, 类型：%T", boolValue, boolValue)
  //  值：false, 类型：bool
}