01 、介绍
关于 Go 语言字符串的使用，我们需要了解标准库 strconv 和标准库 strings 的使用方式，它们分别用于字符串类型转换和字符串操作。
本文我们重点介绍 Go 语言字符串使用方式与技巧。
02 、字符串类型转换
Go 语言是强类型语言，在使用 Go 语言时，通常会遇到需要将字符串与其它类型相互转换的场景。
此时，我们可以使用标准库 strconv。
字符串 to 布尔
示例代码：
func main() {
v := "true"
if s, err := strconv.ParseBool(v); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
}输出结果：
bool, true阅读上面这段代码，我们使用 func ParseBool(str string) (bool, error) 将字符串转换为布尔。需要注意的是，该函数接收参数的值是有限制的，除了 1、t、T、TRUE、true、True、0、f、F、FALSE、false、False 之外，其它任何值都会返回 error。
字符串 to 浮点型
示例代码：
func main() {
v := "3.1415926535"
if s, err := strconv.ParseFloat(v, 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat(v, 64); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("NaN", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
// ParseFloat is case insensitive
if s, err := strconv.ParseFloat("nan", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("inf", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("+Inf", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("-Inf", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("-0", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("+0", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
}输出结果：
float64, 3.1415927410125732
float64, 3.1415926535
float64, NaN
float64, NaN
float64, +Inf
float64, +Inf
float64, -Inf
float64, -0
float64, 0阅读上面这段代码，我们使用 func ParseFloat(s string, bitSize int) (float64, error) 将字符串转换为 64 位浮点数。需要注意的是，该函数接收参数可以识别值为 NaN、Inf（有符号 +Inf 或 -Inf），并且忽略它们的大小写。
字符串 to 整型
示例代码：
func main() {
v32 := "-354634382"
if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
fmt.Printf("s:%T, %v\n", s, s)
}
if s1, err := strconv.ParseInt(v32, 16, 32); err == nil {
fmt.Printf("s1:%T, %v\n", s1, s1)
}
v64 := "-3546343826724305832"
if s2, err := strconv.ParseInt(v64, 10, 64); err == nil {
fmt.Printf("s2:%T, %v\n", s2, s2)
}
if s3, err := strconv.ParseInt(v64, 16, 64); err == nil {
fmt.Printf("s3:%T, %v\n", s3, s3)
}
}输出结果：
s:int64, -354634382
s2:int64, -3546343826724305832阅读上面这段代码，我们使用 func ParseInt(s string, base int, bitSize int) (i int64, err error) 将字符串转换为整型。
需要注意的是，该函数的第一个入参为字符串类型的数值，可以 "+" 或 "-" 符号开头；
第二个参数指定进制，它的值如果是 0，进制则以第一个参数符号后的前缀决定，例如："0b" 为 2，"0" 或 "0o" 为 8，"0x" 为 16，否则为 10；
第三个参数指定返回结果必须符合整数类型的取值范围，它的值为 0、8、16、32 和 64，分别代表 int、int8、int16、int32 和 int64。
细心的读者朋友们可能已经发现，示例代码中，第 2 和 第 4 返回错误，原因是第二个参数指定的进制与第一个参数的数值不相符，超出取值范围。
此外，函数 func ParseUint(s string, base int, bitSize int) (uint64, error) 与之类似，但是用于无符号整数。
在实际项目开发中，十进制使用的最多，所以标准库 strconv 提供了函数 func Atoi(s string) (int, error)，它的功能类似 ParseInt(s, 10, 0)，需要注意的是，它的返回值类型是 int（需要注意取值范围），而不是 int64。
布尔 to 字符串
示例代码：
func main() {
v := true
s := strconv.FormatBool(v)
fmt.Printf("%T, %v\n", s, s)
}输出结果：
string, true阅读上面这段代码，我们使用 func FormatBool(b bool) string 将布尔转换为字符串。
浮点型 to 字符串
示例代码：
func main() {
v := 3.1415926535
s32 := strconv.FormatFloat(v, 'E', -1, 32)
fmt.Printf("%T, %v\n", s32, s32)
s64 := strconv.FormatFloat(v, 'E', -1, 64)
fmt.Printf("%T, %v\n", s64, s64)
fmt64 := strconv.FormatFloat(v, 'g', -1, 64)
fmt.Printf("%T, %v\n", fmt64, fmt64)
}输出结果：
string, 3.1415927E+00
string, 3.1415926535E+00
string, 3.1415926535阅读上面这段代码，我们使用 func FormatFloat(f float64, fmt byte, prec, bitSize int) string 将浮点型转换为字符串。该函数包含 4 个参数，第一个参数是需要转换的浮点数；第二个参数是进制；第三个参数是精度，第四个参数是转换后值的取值范围。
其中，第二个参数 b 代表二进制指数；e 或 E 代表十进制指数；f 代表无进制指数；g 或 G 代表指数大时 为 e，反之为 f；x 或 X 代表十六进制分数和二进制指数。
第三个参数，精度 prec 控制由 'e'，'E'，'f'，'g'，'G'，'x' 和 'X' 格式打印的位数(不包括指数)。对于 'e'，'E'，'f'，'x' 和 'X'，它是小数点后的位数。对于 'g' 和 'G'，它是有效数字的最大数目(去掉后面的零)。特殊精度 -1 使用所需的最小位数，以便 ParseFloat 精确返回 f。
整型 to 字符串
示例代码：
func main() {
v := int64(-42)
s10 := strconv.FormatInt(v, 10)
fmt.Printf("%T, %v\n", s10, s10)
s16 := strconv.FormatInt(v, 16)
fmt.Printf("%T, %v\n", s16, s16)
}输出结果：
string, -42
string, -2a阅读上面这段代码，我们使用 func FormatInt(i int64, base int) string 将整型转换为字符串。需要注意的是，第二个参数的取值范围 2
