数据类型转化

2022-02-04 大约 4 分钟

go在不同类型的变量之间赋值时需要显示转化，并且只有显示转化(强制转化)

语法：

表达式T(v)将值v转化为类型T
T：就是数据类型
v：就是需要转化的变量

1
2
3

# 整型之间的转化

package main

import "fmt"

func main() {
	var num int = 100

	// 不能使用自动转化
	//var num2 float32 = num
	//fmt.Println(num2) // cannot use num (type int) as type float32 in assignment

	// 将int强制转化为float32
	var num2 float32 = float32(num)
	fmt.Println(num2) // 100

	// 将 float64 转化为int8时，编译器并不会报错，但是会数据溢出
	var num3 float64 = 888888
	var num4 int8 = int8(num3)
	fmt.Println(num4) // 56

  // 将int32强制转化为int64
	var num5 int32 = 12
	// 下面这种会出错，因为 num5 + 20的结果是int32，和int64类型不一致
	//var num6 int64 = num5 + 20
	var num6 int64 = int64(num5) + 20
	fmt.Println(num6) // 32

  // 将int64强制转化为int8
	var num7 int64 = 120
	// 正常输出：可能会溢出，因为相加后的结果可能超过127
	var num8 int8 = int8(num7) + 127
	// 报错：因为int8的取值范围是-128~127，而128已经超过最大值127
	//var num9 int8 = int8(num7) + 128
	fmt.Println(num8) // -9
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 基本数据类型转字符串

在程序开发中，我们经常需要将基本数据类型转成string类型。或者将string类型转成基本数据类型。

语法：

方式一

func Sprintf(format string, a ...interface{}) string

Sprintf根据format参数生成格式化的字符串并返回该字符串。

fmt.Sprintf("%参数", 表达式)

方式二
```
使用strconv包含的函数
```
1

# 方式一

package main

import "fmt"

func main() {
	var n1 int = 19
	var s1 string = fmt.Sprintf("%d", n1)
	fmt.Printf("s1对应的类型是：%T; s1 = %q\n", s1, s1)

	var n2 float32 = 4.79
	var s2 string = fmt.Sprintf("%f", n2)
	fmt.Printf("s2对应的类型是：%T; s2 = %q\n", s2, s2)

	var n3 bool = false
	var s3 string = fmt.Sprintf("%t", n3)
	fmt.Printf("s3对应的类型是：%T; s3 = %q\n", s3, s3)

	var n4 byte = 'a'
	var s4 string = fmt.Sprintf("%c", n4)
	fmt.Printf("s4对应的类型是：%T; s4 = %q\n", s4, s4)
}

// 打印结果如下
// s1对应的类型是：string; s1 = "19"
// s2对应的类型是：string; s2 = "4.790000"
// s3对应的类型是：string; s3 = "false"   
// s4对应的类型是：string; s4 = "a"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 方式二

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var n1 int = 19
	var s1 string = strconv.FormatInt(int64(n1), 10)
	fmt.Printf("s1对应的类型是：%T; s1 = %q\n", s1, s1)

	var n2 float32 = 4.29
	// 第二个参数：‘f’(-ddd.dddd) 第三个参数：9 保留小数点后面9位
	var s2 string = strconv.FormatFloat(float64(n2), 'f', 9, 64)
	fmt.Printf("s2对应的类型是：%T; s2 = %q\n", s2, s2)

	var n3 bool = false
	var s3 string = strconv.FormatBool(n3)
	fmt.Printf("s3对应的类型是：%T; s3 = %q\n", s3, s3)
}
// 打印结果如下：
// s1对应的类型是：string; s1 = "19"
// s2对应的类型是：string; s2 = "4.289999962"
// s3对应的类型是：string; s3 = "false"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 字符串转为基本数据类型

使用strconv包的函数

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// string -> bool
	var s1 string = "true"
	var b bool

	// ParseBool这个函数的返回值有两个：(value bool, err error)
	// value 就是我们得到的布尔类型的数据，err表示出现的错误
	// 我们只关注得到的布尔类型的数据，err 可以用 _ 直接忽略
	b, _ = strconv.ParseBool(s1)
	fmt.Printf("b对应的类型是：%T; b = %v\n", b, b)

	// string -> int64
	var s2 string = "19"
	var num1 int64
	num1, _ = strconv.ParseInt(s2, 10, 64)
	fmt.Printf("num1对应的类型是：%T; num1 = %v\n", num1, num1)

	// string -> float32/float64
	var s3 string = "3.14"
	var f1 float64
	f1, _ = strconv.ParseFloat(s3, 64)
	fmt.Printf("f1对应的类型是：%T; f1 = %v\n", f1, f1)
}

// 打印结果如下:
// b对应的类型是：bool; b = true
// num1对应的类型是：int64; num1 = 19
// f1对应的类型是：float64; f1 = 3.14