golang基本数据类型转换方式

golang数据类型转换

一、简单类型转换

1、对于相同底层结构类型的变量，go语言可以使用简单类型转换的方式
例如：byte转string

// 字符类型
var a byte = 'y'

// 转换为字符串类型
b := string(a)

int转float16

// int类型
a := 3

// int转float16
b := float16(a)

2、但是跨越大类型的转换使用这类简单的转换方式是不被允许的（例如：string和int、float、bool之间的转换）

二、借用内置函数strconv进行转换

strconv包中使用最多的函数主要有：
· 字符串转int：Atoi()
· int转字符串：Itoa()
· Parse系列函数将string转为其他类型：ParseType()
· Format系列函数将其他类型转为string：FormatType()
· Append系列函数将其他类型转为string并添加到slice：AppendType()

1、Atoi()字符串类型转整型 （alphanumeric to integer）

原函数类型：func Atoi(s string) (i int, err error)

package main

import (
	"fmt"
	"strconv"
)

//string转换为int
func main(){
	var str string = "12"
	i,err:= strconv.Atoi(str)
	if err != nil {
		// 转换失败！Type:int , Value:0
		fmt.Printf("转换失败！Type:%T , Value:%v", i, i)
	}else{
		// 转换成功！Type:int , Value:12
		fmt.Printf("转换成功！Type:%T , Value:%v", i, i)
	}
}

2、Itoa()整型转字符串类型（integer to alphanumeric）

原函数类型：func Itoa(i int) string

package main

import (
	"fmt"
	"strconv"
)

func main(){
	var str int = 32
	// 转换后结果:32
	fmt.Println("转换后结果:"+strconv.Itoa(str))
}

3、Parse系列函数转换（string转换为其他类型）

• ParseBool()
• ParseInt()
• ParseUint()
• ParseFloat()

ParseBool()

原函数类型：func ParseBool(str string) (value bool, err error)

package main

import (
	"fmt"
	"strconv"
)

func main(){
	// 当入参为"true"/"True"/"TRUE"/"t"/"T"/"1"时转换结果为True，否则为False
	var str string = "true"
	b,err := strconv.ParseBool(str)
	if err != nil {
		// 转换失败！Type:bool , Value:false
		fmt.Printf("转换失败！Type:%T , Value:%v", b, b)
	}else{
		// 转换成功！Type:bool , Value:true
		fmt.Printf("转换成功！Type:%T , Value:%v", b, b)
	}
}

ParseInt()

原函数类型：func ParseInt(s string, base int, bitSize int) (i int64, err error)
参数说明：

• base 指定进制，取值范围是 2 到 36。如果 base 为 0，则会从字符串前置判断，“0x”是 16 进制，“0”是 8 进制，否则是 10 进制。
• bitSize 指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64。
• 返回的 err 是 *NumErr 类型的，如果语法有误，err.Error = ErrSyntax，如果结果超出类型范围 err.Error = ErrRange。

package main

import (
	"fmt"
	"strconv"
)

func main(){
	var str string = "123"
	b,err := strconv.ParseInt(str,10,64)
	if err != nil {
		// 转换失败！Type:int64 , Value:0
		fmt.Printf("转换失败！Type:%T , Value:%v", b, b)
	}else{
		// 转换成功！Type:int64 , Value:123
		fmt.Printf("转换成功！Type:%T , Value:%v", b, b)
	}

}

ParseUint()

原函数类型：func ParseUint(s string, base int, bitSize int) (n uint64, err error)
ParseUint()和ParseInt()在使用方式上类似，仅是入参需使用无符号整型

ParseFloat()

函数原型：func ParseFloat(s string, bitSize int) (f float64, err error)
参数说明：

• 如果 s 合乎语法规则，函数会返回最为接近 s 表示值的一个浮点数（使用 IEEE754 规范舍入）。
• bitSize 指定为64，只能返回float64类型的浮点数(当输入32时会得到异常数值。。。)；
• 返回值 err 是 *NumErr 类型的，如果语法有误 err.Error=ErrSyntax，如果返回值超出表示范围，返回值 f 为 ±Inf，err.Error= ErrRange。

package main

import (
   "fmt"
   "strconv"
)

func main(){
   var str string = "3.1415926"
   b,err := strconv.ParseFloat(str,64)
   if err != nil {
   	// 转换失败！Type:float64 , Value:0
   	fmt.Printf("转换失败！Type:%T , Value:%v", b, b)
   }else{
   	// 转换成功！Type:float64 , Value:3.1415926
   	fmt.Printf("转换成功！Type:%T , Value:%v", b, b)
   }

}

4、FormatType()系列函数转换（其他类型转换为string）

• FormatBool()
• FormatInt()
• FormatUint()
• FormatFloat()

FormatBool()

原函数类型：func FormatBool(b bool) string

// 传入参数为true，false
s := strconv.FormatBool(true)

FormatInt()、FormatUint()

原函数类型：func FormatInt/FormatUint(i int64/uint64, base int) string
参数base表示将数据以多少进制转换为string类型，base的有效值为2~36，从10 ~35以英文字母a ~z代替

package main

import (
	"fmt"
	"strconv"
)

func main(){
	// 入参类型为int64
	var i int64 = 71
	s := strconv.FormatInt(i,36)
	// Type:string , Value:1z
	fmt.Printf("Type:%T , Value:%v", s, s)
}

FormatFloat()

原函数类型：func FormatFloat(f float64, fmt byte, prec, bitSize int) string
参数说明：

• fmt：设置输出数据的格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为二进制）、‘e’（-d.dddde±dd，十进制指数）、‘E’（-d.ddddE±dd，十进制指数）、‘g’（指数很大时用’e’格式，否则’f’格式）、‘G’（指数很大时用’E’格式，否则’f’格式）
• prec：控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示小数点后的数字个数，当精度变小时不完全按照四舍五入的规则进行处理；对’g’、‘G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f
• bitSize：指定数据类型，32表示float32，64表示float64

package main

import (
	"fmt"
	"strconv"
)

func main(){
	// 当丢失精度时并不遵循四舍五入规则，使用时需注意
	fmt.Println(strconv.FormatFloat(411517.135,'f',2,64)) // 411517.14
	fmt.Println(strconv.FormatFloat(411517.115,'f',2,64)) // 411517.11
	fmt.Println(strconv.FormatFloat(411517.135,'e',2,64)) // 4.12e+05
	fmt.Println(strconv.FormatFloat(411517.135,'f',-1,64)) // 411517.135
}

5、AppendType()系列函数转换（其他类型转换为string后加入切片中）

• FormatBool：func AppendBool(slice []byte, b bool) []byte
• FormatInt：func AppendInt(slice []byte, i int64, base int) []byte
• FormatUint：func AppendUint(slice []byte, i uint64, base int) []byte
• FormatFloat：func AppendFloat(slice []byte, f float64, fmt byte, prec, bitSize int) []byte
  相比于Format系列函数，Append系列函数新增了一个切片类型入参作为转换后的string要添加的对象

package main

import (
	"fmt"
	"strconv"
)

func main(){
	s := []byte("int (base 10):")
	fmt.Println(string(strconv.AppendBool(s,true))) // int (base 10):true
	fmt.Println(string(strconv.AppendInt(s,-123,10))) // int (base 10):-123
	fmt.Println(string(strconv.AppendUint(s,123,10))) // int (base 10):123
	fmt.Println(string(strconv.AppendFloat(s,-123.123,'f',2,64))) // int (base 10):-123.12
}

参考文章：
链接: Go基础系列：数据类型转换(strconv包) - 骏马金龙