Go基础系列：数据类型转换(strconv包)

go不会对数据进行隐式的类型转换，只能手动去执行转换操作。

简单的转换操作

转换数据类型的方式很简单。

valueoftypeb = typeb(valueoftypea)

例如：

// 浮点数
a := 5.0

// 转换为int类型
b := int(a)

go允许在底层结构相同的两个类型之间互转。例如：

// it类型的底层是int类型
type it int

// a的类型为it，底层是int
var a it = 5

// 将a(it)转换为int，b现在是int类型
b := int(5)

// 将b(int)转换为it，c现在是it类型
c := it(b)

但注意：

1. 不是所有数据类型都能转换的，例如字母格式的string类型"abcd"转换为int肯定会失败
   
2. 低精度转换为高精度时是安全的，高精度的值转换为低精度时会丢失精度。例如int32转换为int16，float32转换为int
   
3. 这种简单的转换方式不能对int(float)和string进行互转，要跨大类型转换，可以使用strconv包提供的函数

strconv

strconv包提供了简单数据类型之间的类型转换功能。可以将简单类型转换为字符串，也可以将字符串转换为其它简单类型。

这个包里提供了很多函数，大概分为几类：

• 字符串转int：atoi()
  
• int转字符串: itoa()
  
• parsetp类函数将string转换为tp类型：parsebool()、parsefloat()、parseint()、parseuint()。因为string转其它类型可能会失败，所以这些函数都有第二个返回值表示是否转换成功
  
• 其它类型转string类型：formatbool()、formatfloat()、formatint()、formatuint()
  
• appendtp类函数用于将tp转换成字符串后append到一个slice中：appendbool()、appendfloat()、appendint()、appenduint()

还有其他一些基本用不上的函数，见官方手册：go doc strconv或者https://golang.org/pkg/strconv/。

当有些类型无法转换时，将报错，返回的错误是strconv包中自行定义的error类型。有两种错误：

var errrange = errors.new("value out of range")
var errsyntax = errors.new("invalid syntax")

例如，使用atoi("a")将"a"转换为int类型，自然是不成功的。如果print输出err信息，将显示：

strconv.atoi: parsing "a": invalid syntax

string和int的转换

最常见的是字符串和int之间的转换：

1.int转换为字符串：itoa()

// itoa(): int -> string
println("a" + strconv.itoa(32))  // a32

2.string转换为int：atoi()

func atoi(s string) (int, error)

由于string可能无法转换为int，所以这个函数有两个返回值：第一个返回值是转换成int的值，第二个返回值判断是否转换成功。

// atoi(): string -> int
i,_ := strconv.atoi("3")
println(3 + i)   // 6

// atoi()转换失败
i,err := strconv.atoi("a")
if err != nil {
    println("converted failed")
}

parse类函数

parse类函数用于转换字符串为给定类型的值：parsebool()、parsefloat()、parseint()、parseuint()。

由于字符串转换为其它类型可能会失败，所以这些函数都有两个返回值，第一个返回值保存转换后的值，第二个返回值判断是否转换成功。

b, err := strconv.parsebool("true")
f, err := strconv.parsefloat("3.1415", 64)
i, err := strconv.parseint("-42", 10, 64)
u, err := strconv.parseuint("42", 10, 64)

parsefloat()只能接收float64类型的浮点数。

parseint()和parseuint()有3个参数：

func parseint(s string, base int, bitsize int) (i int64, err error)
func parseuint(s string, base int, bitsize int) (uint64, error)

bitsize参数表示转换为什么位的int/uint，有效值为0、8、16、32、64。当bitsize=0的时候，表示转换为int或uint类型。例如bitsize=8表示转换后的值的类型为int8或uint8。

base参数表示以什么进制的方式去解析给定的字符串，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析。

以10进制方式解析"-42"，保存为int64类型：

i, _ := strconv.parseint("-42", 10, 64)

以5进制方式解析"23"，保存为int64类型：

i, _ := strconv.parseint("23", 5, 64)
println(i)    // 13

因为5进制的时候，23表示进位了2次，再加3，所以对应的十进制数为5*2+3=13。

以16进制解析23，保存为int64类型：

i, _ := strconv.parseint("23", 16, 64)
println(i)    // 35

因为16进制的时候，23表示进位了2次，再加3，所以对应的十进制数为16*2+3=35。

以15进制解析23，保存为int64类型：

i, _ := strconv.parseint("23", 15, 64)
println(i)    // 33

因为15进制的时候，23表示进位了2次，再加3，所以对应的十进制数为15*2+3=33。

format类函数

将给定类型格式化为string类型：formatbool()、formatfloat()、formatint()、formatuint()。

s := strconv.formatbool(true)
s := strconv.formatfloat(3.1415, 'e', -1, 64)
s := strconv.formatint(-42, 16)
s := strconv.formatuint(42, 16)

formatint()和formatuint()有两个参数：

func formatint(i int64, base int) string
func formatuint(i uint64, base int) string

第二个参数base指定将第一个参数转换为多少进制，有效值为2<=base<=36。当指定的进制位大于10的时候，超出10的数值以a-z字母表示。例如16进制时，10-15的数字分别使用a-f表示，17进制时，10-16的数值分别使用a-g表示。

例如：formatint(-42, 16)表示将-42转换为16进制数，转换的结果为-2a。

formatfloat()参数众多：

func formatfloat(f float64, fmt byte, prec, bitsize int) string

bitsize参数表示转换为多少位(32或64)的浮点数对应的字符串。

append类函数

appendtp类函数用于将tp转换成字符串后append到一个slice中：appendbool()、appendfloat()、appendint()、appenduint()。

append类的函数和format类的函数工作方式类似，只不过是将转换后的结果追加到一个slice中。

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 声明一个slice
    b10 := []byte("int (base 10):")
    
    // 将转换为10进制的string，追加到slice中
    b10 = strconv.appendint(b10, -42, 10)
    fmt.println(string(b10))

    b16 := []byte("int (base 16):")
    b16 = strconv.appendint(b16, -42, 16)
    fmt.println(string(b16))
}

输出结果：

int (base 10):-42
int (base 16):-2a