go之数据类型转换和类型断言
一、类型转换
1.1 简单类型转换
- 格式
valueOfTypeB = typeB(valueOfTypeA)
- int 转 float64
package main
import "fmt"
func main(){
var num int = 12
var f float64
f = float64(num)
fmt.Println(f)
}
- float64 转int
package main
import "fmt"
// float64 -> int
func main(){
var f float64 = 12.4341
var num int
num = int(f)
fmt.Println(num)
}
- float64 转 uint8
package main
import "fmt"
// float64 -> int
func main(){
var f float64 = 257.4341
var num uint8
num = uint8(f)
fmt.Println(num)
}
结果：
1
为什么不是257？
因为uint8的数字范围是 0 ～255，而257 明显超过了0~255，所以go会重新从0开始，此时257 也就是 1
- 注意
1、不是所有的数据类型都可以转换的，例如string 转 int 就不可以
2、低精度转化成高精度是安全的，但是高精度转低精度就会丢失精度
3、简单的类型转换方式不能对int(float) 和 string 互转，需要通过strconv 包实现
1.2 strconv
- strconv 包提供了简单的数据类型之间的类型转换功能
- int -> string
var num int = 12
var s string
s = strconv.Itoa(num)
- int -> string
var str string = "34"
var n int
n,err := strconv.Atoi(str) // string 类型的数据并不一定是整型数据。
if err != nil {
fmt.Println("str 不是合法的int型的数据")
}
- string -> bool
- string -> int
- string -> float
- string -> uint
package main
import (
"fmt"
"strconv"
)
func main(){
var (
str1 = "true"
str2 = "3.1415"
str3 = "-42"
str4 = "256"
)
var b bool
b,err := strconv.ParseBool(str1)
if err != nil{
fmt.Println("str1 不是合法的 bool型的数据")
}
fmt.Println(b)
var f float64
f,err = strconv.ParseFloat(str2,64) // 64 表示64位
if err != nil{
fmt.Println("str2 不是合法的 float64型的数据")
}
fmt.Println(f)
var i int64
i ,err = strconv.ParseInt(str3,10,64) // 第二个参数10 表示是多少进制的，第三位是int64类型的数据
if err != nil{
fmt.Println("str3 不是合法的 int64型的数据")
}
fmt.Println(i)
var u uint64
u,err = strconv.ParseUint(str4,10,8)
if err !=nil {
fmt.Println("str4 不是合法的 uin8型的数据")
}
fmt.Println(u)
}
结果：
true
3.1415
-42
str4 不是合法的 uin8型的数据
255
- float -> string
- int -> string
- uint -> string
- bool -> string
package main
import (
"fmt"
"strconv"
)
func main() {
var (
b bool = true
f float64 = 3.141555
i int64 = -42
u uint64 = 24
)
// bool -> string
var str1 string
str1 = strconv.FormatBool(b)
fmt.Println(str1)
// float -> string
var str2 string
str2 = strconv.FormatFloat(f, 'f', -1, 64) // 第二个参数是格式，
fmt.Println(str2)
// int -> string
var str3 string
str3 = strconv.FormatInt(i, 10) // 第二个参数10 表示是多少进制的
fmt.Println(str3)
// uint ->string
var str4 string
str4 = strconv.FormatUint(u, 10)
fmt.Println(str4)
}
结果：
true
3.1415
-42
24
类型断言
- 什么是类型断言
断言某种数据的类型
- 为什么要用类型断言
在go语言中接口值的动态类型是不确定的
- 如何使用类型断言
变量,ok = 空接口变量.(数据类型)
- 简单运用
package main
import "fmt"
func main(){
var num interface{}
num = 12
i,ok := num.(int)
if !ok{
fmt.Println("num 不是int类型的数据")
}
fmt.Println(i)
var str interface{}
str = "jmz"
u,ok := str.(uint)
if !ok {
fmt.Println("str 不是uint类型的数据")
}
fmt.Println(u)
}
结果：
12
str 不是uint类型的数据
0
- 为什么下面的转换就不行
package main
import "fmt"
type Enum int
func main(){
var n Enum = 12
var i interface{}
i = n
num ,ok := i.(int)
if !ok {
fmt.Println("i 不是 int 类型")
}
fmt.Println(num)
}
结果
i 不是 int 类型
0
疑问：
12 明明可以是int 类型，为什么不能断言成int类型？
上面说接口值的动态类型是不确定的，应该可以转换成int呀？
解惑：
1、golang 中的变量包含有两个部分（type,value），变量的类型和值
2、每一个interface变量对应的是一个pair，pair 记录的是实际的类型和值
例子：
var num interface{} = 12 // 该变量 对应的pair是（nil,12）
var str string = "jmz"
var s interface{} = str // 该变量对应的pair 是(string,"jmz")
因为：
var n Enum = 12
var i interface{}
i = n // i 接口变量指向的pair的实际类型和值是(Enum,12)
所以：
num ,ok := i.(int) // i是不能断言成int 的，因为i 的动态类型是明确的 Enum
- 注意
1、在golang 中一种特殊类型：interface{} 类型，所有类型都默认继承了interface{} 类型
2、golang 中的变量包含有两个部分（type,value） 即 变量的类型和变量的值
3、每一个interface 变量都有一个对应的pair ,pair 记录了实际的变量的值和类型（type,value）
4、interface{}类型的变量包含了2个指针，一个指针指向值的类型，一个指针指向实际的值
如果喜欢看小说，请到183小说网
