字符串和数值类型的相互转换

实际开发中我们往往需要对一些常用的数据类型进行转换。熟练掌握能让我们编写程序时事半功倍。

string和int类型之间的转换

这个应该是平常开发中最容易遇到的类型转换了

Itoa()

Itoa() 函数用于将 int 类型数据转换为对应的字符串类型

package main
import (
	"fmt"
	"strconv"
)
func main() { /*{不能单独占一行*/
	num := 69
	str := strconv.Itoa(num)
	fmt.Println(str)
	fmt.Printf("str type:%T\n", str)
}

输出：

69

str type:string

Atoi()

Atoi() 函数用于将字符串类型的整数转换为 int 类型.

func Atoi(s string) (i int, err error)
package main
import (
	"fmt"
	"strconv"
)
func main() { /*{不能单独占一行*/
	str1 := "69"
	str2 := "i69"
	num1,err := strconv.Atoi(str1)
	if err != nil{
		fmt.Println("转换失败!",str1)
	}else{
		fmt.Printf("转换成功! value:%d type:%T\n",num1,num1)
	}
	num2,err := strconv.Atoi(str2)
	if err != nil{
		fmt.Println("转换失败!",str2)
	}else{
		fmt.Printf("转换成功! value:%d type:%T\n",num2,num2)
	}
}

输出:

转换成功! value:69 type:int
转换失败! i6a

Parse系列

ParseBool()

ParseBool() 函数用于将字符串转换为 bool 类型的值，它只能接受 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE，其它的值均返回错误。

package main
import (
	"fmt"
	"strconv"
)
func main() { /*{不能单独占一行*/
	str1 = "2"
	str2 = "t"
	bool1,err := strconv.ParseBool(str1)
	if err != nil{
		fmt.Println("转换失败!",str1)
	}else{
		fmt.Printf("转换成功! value:%v type:%T\n",bool1,bool1)
	}
	bool2,err := strconv.ParseBool(str2)
	if err != nil{
		fmt.Println("转换失败!",str2)
	}else{
		fmt.Printf("转换成功! value:%v type:%T\n",bool2,bool2)
	}
}

输出：

转换失败! 2
转换成功! value:true type:bool

ParseInt()

ParseInt() 函数用于返回字符串表示的整数值（可以包含正负号）

func ParseInt(s string, base int, bitSize int) (i int64, err error)
package main

import (
	"fmt"
	"strconv"
)

func main() { /*{不能单独占一行*/
	str1 := "-69"
	str2 := "18461890471234"
	num1,err := strconv.ParseInt(str1,10,32)
	if err != nil{
		fmt.Println(err)
	}else{
		fmt.Printf("value:%d type:%T\n",num1,num1)
	}
	num2,err := strconv.ParseInt(str2,10,32)
	if err != nil{
		fmt.Println(err)
	}else{
		fmt.Printf("value:%d type:%T\n",num2,num2)
	}
}

输出：

value:-69 type:int64
strconv.ParseInt: parsing “18461890471234”: value out of range

注：ParseUnit()与ParseInt()函数类似，只是不接受正负号

ParseFloat()

ParseFloat() 函数用于返回字符串表示的浮点数

func ParseFloat(s string, bitSize int) (f float64, err error)
package main

import (
	"fmt"
	"strconv"
)

func main() { /*{不能单独占一行*/
	str2 := "1846.34"
	num2,err := strconv.ParseFloat(str2,64)
	if err != nil{
		fmt.Println(err)
	}else{
		fmt.Printf("value:%f type:%T\n",num2,num2)
	}
}

输出：

value:1846.340000 type:float64

Format系列

FormatBool(): bool -> string

FormatBool() 函数可以一个 bool 类型的值转换为对应的字符串类型

package main

import (
   "fmt"
   "strconv"
)

func main() { /*{不能单独占一行*/
   bool1 := false
   str1 := strconv.FormatBool(bool1)
   fmt.Printf("value:%s type:%T",str1,str1)
}

输出：

value:false type:string

FormatInt(): int -> string

FormatInt() 函数用于将整型数据转换成指定进制并以字符串的形式返回

func FormatInt(i int64, base int) string
package main

import (
	"fmt"
	"strconv"
)

func main() { /*{不能单独占一行*/
	var num1 int64 = 100
	str1 := strconv.FormatInt(num1,8)
	fmt.Printf("value:%s type:%T\n",str1,str1)
	str1 = strconv.FormatInt(num1,16)
	fmt.Printf("value:%s type:%T\n",str1,str1)
}

func FormatUint(i uint64, base int) string

FormatFloat(): float -> string

FormatFloat() 函数用于将浮点数转换为字符串类型.

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

import (
	"fmt"
	"strconv"
)

func main() { /*{不能单独占一行*/
	var num1 float64 = 324.2148
	str1 := strconv.FormatFloat(num1,'f',4,64)
	fmt.Printf("value:%s type:%T\n",str1,str1)
	str1 = strconv.FormatFloat(num1,'e',5,64)
	fmt.Printf("value:%s type:%T\n",str1,str1)
}

输出：

value:324.2148 type:string
value:3.24215e+02 type:string

Append系列

Append 系列函数用于将指定类型转换成字符串后追加到一个切片中.包含 AppendBool()、AppendFloat()、AppendInt()、AppendUint().

package main
import (
	"fmt"
	"strconv"
)
func main() { /*{不能单独占一行*/
	Slice := []byte("int (base 10): ")
	Slice = strconv.AppendInt(Slice,100,10)
	fmt.Println(string(Slice))
}

输出：

int (base 10):100