go之数据类型转换和类型断言

一、类型转换

1.1 简单类型转换

• 格式

valueOfTypeB = typeB(valueOfTypeA)


• int 转 float64

package mainimport "fmt"func main(){
var num int = 12
var f float64
f = float64(num)
fmt.Println(f)
}

• float64 转int

package mainimport "fmt"// float64 -> int
func main(){
var f float64 = 12.4341
var num int
num = int(f)
fmt.Println(num)
}


• float64 转 uint8

package mainimport "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 mainimport (
"fmt"
"strconv"
)func main(){
var (
str1 = "true"
str2 = "3.1415"
str3 = "-42"
str4 = "256"
)var b boolb,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 mainimport (
"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 mainimport "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 mainimport "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小说网