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

转载于:https://www.cnblogs.com/xiaobaiskill/p/10667849.html