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

  • 相关阅读:
    第01组 Beta冲刺(4-5)
    第01组 Beta冲刺(3-5)
    第01组 Beta冲刺(2-5)
    第01组 Beta冲刺(1-5)
    等价类划分-一个程序输入三个整数,判断三角形是不等边,还是等腰还是等边
    Jmeter入门(8)- Jmeter关联
    Jmeter发送数据库请求(JDBC Request)报错
    Jmeter入门(7)- 连接数据库
    Jmeter入门(6)- 参数化
    Jmeter入门(5)- jmeter取样器的HTTP请求
  • 原文地址:https://www.cnblogs.com/xiaobaiskill/p/10667849.html
Copyright © 2020-2023  润新知