使用strconv进行Go的 int、float、string类型相互转换：灵活转换数据类型

目录

类型断言

数据（变量）类型转换

strconv常用函数总结

int和string类型的互转

fmt.Sprintf

strconv.FormatInt

strconv.ParseInt

float和string类型的互转

fmt.Sprintf

strconv.FormatFloat

strconv.ParseFloat

int和float类型的转换

字符串转换为bool

总结

---

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

在公众号CTO Plus前面的文章《对Go语言字符串操作大揭秘：高效处理文本》中，介绍了非常多strings以及strconv的部分数据类型转换方法。

本文原文：使用strconv进行Go的 int、float、string类型相互转换：灵活转换数据类型

在Go语言中，int、float和string类型之间的相互转换是常见的操作。通过使用strconv包和fmt包中的函数，我们可以方便地进行这些类型的转换。在进行类型转换时，需要注意值的范围和精度，以避免出现错误。

其中，Go语言中的strconv包是用于字符串和基本数据类型之间的相互转换的包。它提供了一系列的函数，可以方便地将字符串转换为基本数据类型，或者将基本数据类型转换为字符串。

本文我将再进一步介绍下Go语言的数据类型相互转换和类型断言，以及strconv包的其他常用函数和代码使用示例。内容包括了不使用strconv的类型转换方法、strconv常用方法总结、整型和字符串的互转、浮点型和字符串的互转、整型和浮点型的互转、字符串和bool类型的转换以及字节类型的转换方法。帮助读者更好地理解和应用数据类型转换。熟练掌握这些类型的转换方法，可以帮助我们更好地处理不同类型之间的数据转换需求。

类型断言

类型断言用于在接口类型中获取其底层具体类型的值。在Go语言中，接口类型是一种特殊的类型，可以用来存储任意类型的值。但是，当我们需要使用接口类型中的具体值时，需要进行类型断言。

关于接口类型的详解介绍和使用请关注公众号CTO Plus后面的文章《Go接口（interface）的奇妙世界：深入理解Go语言中的接口特性》。

示例代码：

package main
import "fmt"
func main() {  var val interface{} = "公众号：CTO Plus"  str, ok := val.(string)  if ok {    fmt.Println(str)  // 公众号：CTO Plus  }else {    fmt.Println("Value is not a string")  }}

在上述示例中，我们定义了一个空接口类型变量val，并将其赋值为字符串类型的值。然后，我们使用类型断言将val转换为字符串类型，并判断转换是否成功。如果转换成功，我们打印出字符串的值；否则，打印出错误信息。

需要注意的是，如果类型断言失败，将会触发运行时错误。因此，在进行类型断言时，需要使用第二个返回值来判断是否转换成功。

数据（变量）类型转换

在Go语言中，不同类型的数据之间不能直接进行运算或赋值。需要使用类型转换将两个变量的值转换为同一类型。类型转换可以通过使用目标类型的名称将值括在括号中来实现。

Go语言中，int、float和string类型之间的相互转换是常见的操作。在实际开发中，我们经常需要将这些类型之间进行转换，以满足不同的需求。下面我们来详细介绍一下如何在Go语言中进行这些类型的转换。

示例代码：

package main
import "fmt"
func varConvert(){  var num1 int = 28  var num2 float64 = 23.456  // 不同类型的变量不能拿来运算  //sum := num2 + num1  // invalid operation: num2 + num1 (mismatched types float64 and int)  sum := num1 + int(num2)  sum2 := float64(num1) + num2  fmt.Println(sum, sum2)  // 51 51.456  // 不同类型的变量不能互相比较  //fmt.Println(sum == sum2) // invalid operation: sum == sum2 (mismatched types int and float64)}

在上述示例中，我们将整型变量num1转换为浮点型，然后与另一个浮点型变量num2相加，得到了一个浮点型的结果。

需要注意的是，类型转换可能会导致精度丢失或溢出。因此，在进行类型转换时，需要谨慎考虑数据范围和精度的问题。这种方法也属于对变量的类型进行强制转换。

func strongConvert()  {  var age int = 28  // 强制类型转换（实际应用场景上也不是一个靠谱的方法）  var height float64 = float64(age)  fmt.Println(age, height)  // 28 28
  var num int = 10  var byteValue byte = byte(num) //int转为byte  newNum := int(byteValue)  //byte转为int  fmt.Printf("%T %T %T", byte(num), byteValue, newNum) // uint8 uint8 int}

在上面的代码中，我们将age变量强制转换为float64类型，并赋值给height变量。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

需要注意的是，类型转换只能在相互兼容的类型之间进行，否则会导致编译错误。

func varConvert02() {  //高精度向低精度转换，数字很小时这种转换没问题  var uValue uint64 = 1  i8Value := int8(uValue)  fmt.Printf("i8Value=%d\n", i8Value) // i8Value=1
  //最高位的1变成了符号位  uValue = uint64(math.MaxUint64)  i64Value := int64(uValue)  fmt.Printf("i64Value=%d\n", i64Value) // i64Value=-1
  //位数丢失  ui32Value := uint32(uValue)  fmt.Printf("ui32Value=%d\n", ui32Value) // ui32Value=4294967295
  //单个字符可以转为int  var num int = int('a')  //输出字母a对应的ASCII码  fmt.Printf("num=%d\n", num) // num=97
  //bool和int不能相互转换
  //byte和int可以互相转换  var itob byte = byte(num)  btoi := int(itob)  fmt.Printf("itob=%d  %T\n", itob, itob) // itob=97  uint8  fmt.Printf("btoi=%d  %T\n", btoi, btoi) // btoi=97  int
  //float和int可以互相转换，小数位会丢失  var float32Value float32 = float32(12345678)  float32ToInt := int(float32Value)  fmt.Printf("float32Value=%d  %T\n", float32Value, float32Value)  // float32Value=%!d(float32=1.2345678e+07)  float32  fmt.Printf("float32ToInt=%d  %T\n", float32ToInt, float32ToInt)  // float32ToInt=12345678  int}

经过上述类型转换代码的示例可以得出下面的结论：

• 低精度向高精度转换没问题，高精度向低精度转换会丢失位数。

• 无符号向有符号转换，最高位是符号位。

• byte和int可以互相转换。

• float和int可以互相转换，小数位会丢失。

• bool和int不能相互转换。

• 不同长度的int或float之间可以相互转换。

strconv常用函数总结

接下来，我先总结下strconv的一些常用函数，Go语言中的strconv包是用于字符串和基本数据类型之间的相互转换的包。它提供了一系列的函数，可以方便地将字符串转换为基本数据类型，或者将基本数据类型转换为字符串。

strconv包提供了以下常用函数：

• strconv.Atoi()：用于将字符串转换为int类型。如果转换失败，将返回一个错误。

• strconv.ParseBool()：用于将字符串转换为bool类型。如果转换失败，将返回一个错误。

• strconv.ParseFloat()：用于将字符串转换为float64类型。如果转换失败，将返回一个错误。

• strconv.ParseInt()：用于将字符串转换为指定进制的int64类型。如果转换失败，将返回一个错误。

• strconv.ParseUint()：用于将字符串转换为指定进制的uint64类型。如果转换失败，将返回一个错误。

• strconv.FormatBool()：用于将bool类型转换为字符串。

• strconv.FormatFloat()：用于将float64类型转换为字符串。

• strconv.FormatInt()：用于将int64类型转换为字符串。

• strconv.FormatUint()：用于将uint64类型转换为字符串。

• strconv.Atoi(str)：将字符串str转换为整数类型。

• strconv.ParseFloat(str, bitSize)：将字符串str转换为浮点数类型，bitSize表示浮点数的位数。

• strconv.Itoa(i)：将整数i转换为字符串类型。

• strconv.FormatFloat(f, 'f', -1, bitSize)：将浮点数f转换为字符串类型，bitSize表示浮点数的位数。

• strconv.ParseBool()：函数用于将字符串解析为布尔值。它接受字符串参数，返回解析后的布尔值和一个错误。如果解析成功，布尔值为true或false，错误为nil；如果解析失败，布尔值为false，错误为相应的解析错误。

• strconv.ParseInt()：函数用于将字符串解析为整数。它接受字符串、进制和位大小参数，返回解析后的整数和一个错误。如果解析成功，整数为解析的值，错误为nil；如果解析失败，整数为0，错误为相应的解析错误。

• strconv.ParseComplex()：函数用于将字符串解析为复数。它接受字符串和位大小参数，返回解析后的复数和一个错误。如果解析成功，复数为解析的值，错误为nil；如果解析失败，复数为0，错误为相应的解析错误。

• strconv.ParseUint()：函数用于将字符串解析为无符号整数。它接受字符串、进制和位大小参数，返回解析后的无符号整数和一个错误。如果解析成功，无符号整数为解析的值，错误为nil；如果解析失败，无符号整数为0，错误为相应的解析错误。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

下面是一些使用strconv包的示例：

int和string类型的互转

将int类型转换为string类型，我们可以使用strconv包中的函数strconv.Itoa()或strconv.FormatInt()。

示例代码：

package main
import (  "fmt"  "strconv")
func main() {  num := 123  str := strconv.Itoa(num) // 基本数据类型转换为字符串  fmt.Printf("int to string: %s\n", str)}将 int 类型的整数转为10进制的字符串表示，底层调用的就是FormatInt(int64(i), 10)方法。
// Itoa is equivalent to FormatInt(int64(i), 10).func Itoa(i int) string {  return FormatInt(int64(i), 10)}

将string类型转换为int类型，，默认字符串是10进制的，可以使用strconv包中的函数strconv.Atoi()或strconv.ParseInt()。

strconv.Atoi相当于是下下面的ParseInt(s, 10, 0) 方法，是10进制转化的简版

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

使用方法

示例代码：

package main
import (  "fmt"  "strconv")
func main() {
strconv.Atoi("1234")  // 1234 <nil>strconv.Atoi("001") // 1 <nil>
  str := "123"  num, err := strconv.Atoi(str)  if err != nil {    fmt.Println("string to int conversion error:", err)    return  }  fmt.Printf("string to int: %d\n", num)}

fmt.Sprintf

将整数转为字符串，我们还可以使用Sprintf，这块的使用方法，可以参考公众号CTO Plus前面的文章《Go语言的打印输出方法总结》

strconv.FormatInt

将整数转为字符串，字符串可选2到36进制的字符串表示。

函数原型：func FormatInt(i int64, base int) string {}

函数参数：

i: int64类型的整数

base: 表示要转为的进制，支持2到36进制，使用最多的就是转为10进制

使用方法

我们可以把int32、int64 先转为 int，然后再使用该方法转换

strconv.Itoa(1123) // 1123

strconv.FormatInt(123, 10) // 123

strconv.FormatInt(123, 2) // 1111011

strconv.ParseInt

strconv.ParseInt()函数用于将字符串转换为整数类型，使用该函数可以实现将string 转为int32、int64、int，字符串可以是不同进制类型的。它接受三个参数：s为要转换的字符串，base为进制数，bitSize为整数类型的位数。

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

下面是strconv.ParseInt()函数的参数详解：

• s string：要转换的字符串（数字的字符串形式）。

• base int：进制数，表示要解析的字符串中的数字的进制。可选值为0、2、8、10和16（支持0以及2-36）。如果base为0，则根据字符串的前缀来确定进制。如果字符串以"0x"或"0X"开头，则认为是十六进制。如果字符串以"0"或"0o"开头，则认为是八进制。如果以"0b"开头，则为2进制。否则，认为是十进制。

• bitSize int：整数类型的位数（返回结果的bit大小），表示要转换的整数类型的范围。可选值为0、8、16、32和64（0 -> int、8 -> int8、16 -> int16、32 -> int32、64 -> int64）。如果bitSize为0，则根据转换的结果来确定整数类型的位数。因为可以选择不同的 bitSize，所以统一转为int64，不会丢失精度。可根据需要的bitSize，自行转回去。

strconv.ParseInt()函数的返回值为转换后的整数值和一个错误值。如果转换成功，则返回转换后的整数值和nil；如果转换失败，则返回0和一个错误信息。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

下面是一个使用strconv.ParseInt()函数的实战案例：

package main
import (    "fmt"    "strconv")
func main() {    str := "12345"    num, err := strconv.ParseInt(str, 10, 32)    if err != nil {        fmt.Println("转换失败：", err)    } else {        fmt.Println("转换成功：", num)    }}

在上面的例子中，我们定义了一个字符串"12345"，然后使用strconv.ParseInt()函数将其转换为整数类型。我们将进制数base设置为10，表示要解析的字符串是十进制数。将位数bitSize设置为32，表示要转换为int32类型的整数。

strconv.ParseInt()函数会将字符串"12345"转换为整数12345，并将其赋值给变量num。如果转换成功，则err的值为nil，我们打印转换成功的消息和转换后的整数值。否则，err的值为一个错误信息，我们打印转换失败的消息和错误信息。

在这个实战案例中，我们将字符串"12345"转换为整数类型，并成功地获得了转换后的整数值12345。这展示了strconv.ParseInt()函数的用法和功能。

// 转int32

num, err := strconv.ParseInt("123",10,32)

fmt.Println(int32(num), err) // 123 <nil>

// 转int64

num, err := strconv.ParseInt("123", 10, 64)

fmt.Println(num, err) // 123 <nil>

// 转int

num, err := strconv.ParseInt("123", 10, 64)

fmt.Println(int(num), err) // 123 <nil>

// 二进制转int64

num, err := strconv.ParseInt("0b1001", 0, 64)

fmt.Println(int(num), err) // 9 <nil>

 字符串转换为int，以及指定进制的int64

package main
import (    "fmt"    "strconv")
func main() {    // 字符串转换为int    numStr := "123"    num, err := strconv.Atoi(numStr)    if err == nil {        fmt.Println(num)    } else {        fmt.Println("转换失败")    }}

在上面的代码中，我们使用strconv.Atoi()函数将字符串"123"转换为int类型的数字。如果转换成功，将打印出转换后的数字123；如果转换失败，将打印出转换失败。

package main
import (    "fmt"    "strconv")
func main() {    // 字符串转换为指定进制的int64    numStr := "FF"    num, err := strconv.ParseInt(numStr, 16, 64)    if err == nil {        fmt.Println(num)    } else {        fmt.Println("转换失败")    }}

在上面的代码中，我们使用strconv.ParseInt()函数将字符串"FF"转换为指定进制（16进制）的int64类型的值。如果转换成功，将打印出转换后的数字255；如果转换失败，将打印出转换失败。

float和string类型的互转

将float类型转换为string类型，可以使用fmt包中的函数fmt.Sprintf()。

示例代码：

package main
import (  "fmt")
func main() {  num := 3.14  str := fmt.Sprintf("%f", num)  fmt.Printf("float to string: %s\n", str)}

将string类型转换为float类型，可以使用strconv包中的函数strconv.ParseFloat()。

示例代码：

package main
import (  "fmt"  "strconv")
func main() {  str := "3.14"    // 字符串转换为float64  num, err := strconv.ParseFloat(str, 64)  if err != nil {    fmt.Println("string to float conversion error:", err)    return  }  fmt.Printf("string to float: %f\n", num)}

在上面的代码中，我们使用strconv.ParseFloat()函数将字符串"3.14"转换为float64类型的值。如果转换成功，将打印出转换后的浮点数3.14；如果转换失败，将打印出转换失败。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

fmt.Sprintf

将整数转为字符串，我们还可以使用Sprintf，这块的使用方法，可以参考公众号CTO Plus前面的文章《Go语言的打印输出方法总结》

strconv.FormatFloat

函数原型

func FormatFloat(f float64, fmt byte, prec, bitSize int) string {

     return string(genericFtoa(make([]byte, 0, max(prec+4, 24)), f, fmt, prec, bitSize))

}

参数释义：

f：float64类型的浮点数

fmt: 转为字符串后，字符串的类型：

• 'b' (-ddddp±ddd)：二进制指数

• 'e' (-d.dddde±dd)：10进制指数

• 'E' (-d.ddddE±dd)：10进制指数

• 'f' (-ddd.dddd)：无指数

• 'g' ：指数很大时使用'e'，其他使用'f'

• 'G' ：指数很大时使用 'E'，其他使用'f'

• 'x' (-0xd.ddddp±ddd)：十六进制分数和二进制指数

• 'X' (-0Xd.ddddP±ddd)：十六进制分数和二进制指数

• prec：控制经度

• 如果格式标记为 'e'、'E'、'f'、'x'、'X'，则 prec 表示小数点后的数字位数

• 如果格式标记为 'g'，'G'，则 prec 表示总的数字位数（整数部分+小数部分）

bitSize：表示f最初的类型。（虽然入参f是float64，有可能是float32转过来的）

使用方法

strconv.FormatFloat(3.1415926, 'f', 5, 64) // 3.14159

strconv.FormatFloat(3.1415926e5, 'f', 5, 64) // 314159.26000

strconv.ParseFloat

func ParseFloat(s string, bitSize int) (float64, error) {  if bitSize == 32 {    f, err := atof32(s)    return float64(f), err  }  return atof64(s)}

参数释义：

• s: 字符串

• bitSize: 要返回结果的精度

方法始终返回float64，即使bitSize=32，返回 float64 也不会丢失精度

使用方法

strconv.ParseFloat("123.213", 64) // 123.213 <nil>

strconv.ParseFloat("123.213e3", 64) // 123213 <nil>

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

int和float类型的转换

将int类型转换为float类型，可以直接进行类型转换。

示例代码：

package main
import (  "fmt")
func main() {  num := 123  f := float64(num)  fmt.Printf("int to float: %f\n", f)}

将float类型转换为int类型，可以使用类型断言。

示例代码：

package main
import (  "fmt")
func main() {  num := 3.14  i := int(num)  fmt.Printf("float to int: %d\n", i)}

需要注意的是，进行类型转换时，要确保转换的值在目标类型的范围内，否则可能会出现溢出或精度丢失的问题。

字符串转换为bool

package main
import (    "fmt"    "strconv")
func main() {    // 字符串转换为bool 此处只能是 "true"或"false"    boolStr := "true"    b, err := strconv.ParseBool(boolStr)    if err == nil {        fmt.Println(b)    } else {        fmt.Println("转换失败")    }}

在上面的代码中，我们使用strconv.ParseBool()函数将字符串"true"转换为bool类型的值。如果转换成功，将打印出转换后的布尔值true；如果转换失败，将打印出转换失败。

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

总结

本文介绍了整形、浮点型、字符串的互相转换方法，Go语言提供了类型转换和类型断言两种方法来实现数据类型的相互转换。类型转换用于将一个类型的值转换为另一个类型，适用于基本数据类型之间的转换。类型断言用于在接口类型中获取其底层具体类型的值，适用于接口类型的值的转换。在进行类型转换和类型断言时，需要注意数据范围、精度和转换成功与否的判断。

strconv包提供了一系列方便的函数，可以在字符串和基本数据类型之间进行相互转换。通过使用这些函数，我们可以轻松地将字符串转换为基本数据类型，或者将基本数据类型转换为字符串。在实际开发中，我们经常需要处理字符串和基本数据类型之间的转换，因此熟练掌握strconv包的使用是很重要的。希望本文对你理解和使用strconv包有所帮助。

通过熟练掌握这两种方法，开发者可以更灵活地处理和操作不同类型的数据。我们可以记住fmt.Sprintf方法、strings包以及strconv 包，用到时根据 IDE 的方法提示就可以搞定了！

更多精彩，关注我公号，一起学习、成长

推荐阅读：

• 开源项目 | 17款云原生安全相关的扫描和平台类开源工具

• Go语言常量解密：恒定不变的值（const与iota）（附代码示例）
  深入了解Go语言的数据类型

• 使用strconv进行Go的 int、float、string类型相互转换：灵活转换数据类型

• Go语言变量的生命周期与作用域

• Go中字符串的遍历技巧：轻松操作文本

• Go语言字符串操作大揭秘：高效处理文本

• Go的流程控制（if、for、switch、goto）全面解析与刨坑

• Go的多端开发环境与编译器的搭建详解（图文）

• Go语言的高级特性，发展趋势，以及推荐最热门的开源项目