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

巴特西

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

一、类型转换

1.1 简单类型转换

1.2 strconv

类型断言

最新文章

热门文章