go语言数据类型转换

lupython

于 2024-04-28 17:47:16 发布

阅读量402

点赞数 3

文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/weixin_41774149/article/details/138286044

版权

go语言数据类型转换

golang不会对数据进行隐式的类型转换，只能手动去执行转换操作，表达式T(v)将值v转换为类型T

T : 就是数据类型
V : 就是需要转换的变量

一、数值类型转换

数值间转换的时候建议从小范围转换成大范围，比如int8转int16，大范围转换成小范围的时候，比如int16转int8，会发生精度丢失（截断）的情况，如果转换不成功就会溢出。

1.1、整数间转换

package main
import "fmt"
func main() {
	var a int8 = 6
	var b int16 = 12
	var c = b + 5 //根据b推导出c也是int16
	fmt.Printf("整数间的数值运算，值：%v ----类型%T\n", c, c)
	c = int16(a) + b
	fmt.Printf("整数间的数值运算，值：%v ----类型%T\n", c, c)
}
	//整数间的数值运算，值：17 ----类型int16
	//整数间的数值运算，值：18 ----类型int16

1.2、浮点数间转换

package main
import "fmt"
func main() {
	var a float32 = 6.1
	fmt.Printf("整数间的数值运算，值：%v ----类型%T\n", a, a)
	//整数间的数值运算，值：6.1 ----类型float32
	fmt.Printf("整数间的数值运算，值：%.1f ----类型%T\n", a, a)
	//整数间的数值运算，值：6.1 ----类型float32
	var d float64 = float64(a)
	fmt.Printf("整数间的数值运算，值：%v ----类型%T\n", d, d)
	//整数间的数值运算，值：6.099999904632568 ----类型float64
	var b float64 = 12.1
	var c = float64(a) + b
	fmt.Printf("整数间的数值运算，值：%v ----类型%T\n", c, c)
	//整数间的数值运算，值：18.19999990463257 ----类型float64
}

1.3、整数与浮点类型间的转换

func main() {
	var a int = 8
	var b float64 = 12.1
	var c = float64(a) + b
	fmt.Printf("整数和浮点数直接的运算，值：%v ----类型%T\n", c, c)
}

二、其他类型转换成String类型

2.1 `fmt.Sprintf()`把其他类型转换成String类型

注意：fmt.Sprintf()使用中需要注意转换的格式，int 为%d, float 为%f, bool为%t, byte 为%c

package main
import "fmt"
func main() {
	var (
		a int     = 20
		b float64 = 12.456
		c bool    = true
		d byte    = 'a'
	)
	var strA, strB, strC, strD string
	strA = fmt.Sprintf("%d", a)
	strB = fmt.Sprintf("%f", b)
	strC = fmt.Sprintf("%t", c)
	strD = fmt.Sprintf("%c", d)
	fmt.Printf("stra类型是%T,值是%v\n", strA, strA)
	fmt.Printf("strb类型是%T,值是%v\n", strB, strB)
	fmt.Printf("strc类型是%T,值是%v\n", strC, strC)
	fmt.Printf("strd类型是%T,值是%v\n", strD, strD)
}
/*stra类型是string,值是20
strb类型是string,值是12.456000
strc类型是string,值是true
strd类型是string,值是a
*/
// 变量命名方式也是两种

2.2、使用`strconv`包把其他类型转换成String类型

2.2.1、int 转换成 String 类型

func main() {
	var (
		a    int64 = 20
		strA string
		b    int = 19
	)
	strA = strconv.FormatInt(a, 10)   //方法1
	fmt.Printf("类型%T,数值%v\n", strA, strA)
	strA = strconv.Itoa(b)  //方法2
	fmt.Printf("类型%T,数值%v\n", strA, strA)
}
//strconv.Itoa()等价于strconv.FormatInt()

2.2.2、float 转换成 String 类型

strconv.FormatFloat(f float64, fmt byte, prec, bitSize int)
参数1是要转换的值，需要时float64类型
参数2是格式化的进制类型
    'f' (-ddd.dddd)
    'b' (-ddddp±ddd，指数为二进制)
    'e'（-d.dddde±dd，十进制指数）、
    'E'（-d.ddddE±dd，十进制指数）、
    'g' (指数很大时用'e'格式，否则'f'格式)
    'G' (指数很大时用'E'格式，否则'f'格式)
参数3是保留的小数点数量，设置为 -1 表示不对小数点格式化 ，设置为 3 表示保留三位小数。
参数4是格式化后的类型为int，位数是设置的bitSize，设置64，那就是格式化后的具体类型为int64。
func main() {
	var a float64 = 20.123456
	star01 := strconv.FormatFloat(a, 'f', -1, 64)
	fmt.Printf("类型%T,数值%v\n", star01, star01)
	//类型string,数值20.123456
	star02 := strconv.FormatFloat(a, 'f', 3, 64)
	fmt.Printf("类型%T,数值%v\n", star02, star02)
	//类型string,数值20.123
}

2.2.3、bool 转 String类型

func main() {
	var a bool = true
	str := strconv.FormatBool(a)
	fmt.Printf("类型%T,数值%v\n", str, str)
	//类型string,数值true
	var b bool = false
	str01 := strconv.FormatBool(b)
	fmt.Printf("类型%T,数值%v\n", str01, str01)
	//类型string,数值false
}

三、String类型转换成数值类型

Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、 ParseUint()。由于字符串转换为其它类型可能会失败，所以这些函数都有两个返回值，第一个返回值保存转换后的值，第二个返回值判断是否转换成功。

3.1、String类型转换成int类型

func main() {
	a := "12"
	num, _ := strconv.ParseInt(a, 10, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num, num)
	a = "hello"
	num, _ = strconv.ParseInt(a, 10, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num, num)
	a = "12.1"
	num, _ = strconv.ParseInt(a, 10, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num, num)
	a = "-12"
	num, _ = strconv.ParseInt(a, 10, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num, num)
	a = "12"
	num, _ = strconv.ParseInt(a, 10, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num, num)
	num01, _ := strconv.ParseUint(a, 10, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num01, num01)
	a = "-12"
	num02, _ := strconv.Atoi(a)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num02, num02)
	a = "12"
	num02, _ = strconv.Atoi(a)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num02, num02)
	a = "hello"
	num02, _ = strconv.Atoi(a)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num02, num02)
}

/*变量hello，类型int64,数值0
变量12.1，类型int64,数值0
变量-12，类型int64,数值-12
变量12，类型int64,数值12
变量12，类型uint64,数值12
变量-12，类型int,数值-12
变量12，类型int,数值12
变量hello，类型int,数值0
*/

//非数字字符串不可以转换为int类型,浮点字符串也不可以转换为int类型
//ParseInt()可以转换正数和负数，ParseUint()只能转换正数
//strconv.Atoi() 等价于ParseInt()

3.2、String类型转换成float类型

func main() {
	a := "12.123456"
	num, _ := strconv.ParseFloat(a, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num, num)
	a = "12"
	num, _ = strconv.ParseFloat(a, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num, num)
	a = "hello"
	num, _ = strconv.ParseFloat(a, 64)
	fmt.Printf("变量%v，类型%T,数值%v\n", a, num, num)
}

/*变量12.123456，类型float64,数值12.123456
变量12，类型float64,数值12
变量hello，类型float64,数值0*/
//非数字字符串不可以转换为float类型

3.3、String类型转换成bool类型

func main() {
	s := "true"
	num, _ := strconv.ParseBool(s)
	fmt.Printf("变量%v，类型%T,数值%v\n", s, num, num)
	s = "false"
	num, _ = strconv.ParseBool(s)
	fmt.Printf("变量%v，类型%T,数值%v\n", s, num, num)
	s = "hello"
	num, _ = strconv.ParseBool(s)
	fmt.Printf("变量%v，类型%T,数值%v\n", s, num, num)
	s = "1"
	num, _ = strconv.ParseBool(s)
	fmt.Printf("变量%v，类型%T,数值%v\n", s, num, num)
	s = "0"
	num, _ = strconv.ParseBool(s)
	fmt.Printf("变量%v，类型%T,数值%v\n", s, num, num)
}

/*变量true，类型bool,数值true
变量false，类型bool,数值false
变量hello，类型bool,数值false
变量1，类型bool,数值true
变量0，类型bool,数值false*/

lupython

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
go语言数据类型转换

注意：fmt.Sprintf()使用中需要注意转换的格式，int 为%d, float 为%f, bool为%t, byte 为%c。注意：fmt.Sprintf()使用中需要注意转换的格式，int 为%d, float 为%f, bool为%t, byte 为%c。转int16，大范围转换成小范围的时候，比如int16转int8，会发生精度丢失（截断）的情况，如果转换不成功就会溢出。为其它类型可能会失败，所以这些函数都有两个返回值，第一个返回值保存转换后的值，第二个返回值判断是否转换成功。
复制链接

扫一扫