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小说网