Go 语言标准库之 strconv 包
Go 语言的 strconv 包实现了字符串与其它类型的互相转换，本文介绍 strconv 包的常用操作。
Parse 类型
字符串解析为布尔值 ParseBool
// 返回字符串表示的 bool 值，接受 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE
func ParseBool(str string) (value bool, err error)
☕️ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
flag, err := strconv.ParseBool("1")
fmt.Println(flag, err) // true <nil>
flag, err = strconv.ParseBool("t")
fmt.Println(flag, err) // true <nil>
flag, err = strconv.ParseBool("T")
fmt.Println(flag, err) // true <nil>
flag, err = strconv.ParseBool("true")
fmt.Println(flag, err) // true <nil>
flag, err = strconv.ParseBool("True")
fmt.Println(flag, err) // true <nil>
flag, err = strconv.ParseBool("TRUE")
fmt.Println(flag, err) // true <nil>
flag, err = strconv.ParseBool("TRue")
fmt.Println(flag, err) // false strconv.ParseBool: parsing "TRue": invalid syntax
flag, err = strconv.ParseBool("0")
fmt.Println(flag, err) // false <nil>
flag, err = strconv.ParseBool("f")
fmt.Println(flag, err) // false <nil>
flag, err = strconv.ParseBool("F")
fmt.Println(flag, err) // false <nil>
flag, err = strconv.ParseBool("false")
fmt.Println(flag, err) // false <nil>
flag, err = strconv.ParseBool("False")
fmt.Println(flag, err) // false <nil>
flag, err = strconv.ParseBool("FALSE")
fmt.Println(flag, err) // false <nil>
flag, err = strconv.ParseBool("FALse")
fmt.Println(flag, err) // false strconv.ParseBool: parsing "FALse": invalid syntax
}
字符串解析为有符号整数 ParseInt
// 将字符串解析为整数，接受正负号
// 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
func ParseInt(s string, base int, bitSize int) (i int64, err error)
⭐️ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
num, err := strconv.ParseInt("123", 10, 8)
fmt.Println(num, err) // 123 <nil>
num, err = strconv.ParseInt("12345", 10, 8)
fmt.Println(num, err) // 127 strconv.ParseInt: parsing "12345": value out of range
num, err = strconv.ParseInt("2147483647", 10, 0)
fmt.Println(num, err) // 2147483647 <nil>
num, err = strconv.ParseInt("0xFF", 16, 0)
fmt.Println(num, err) // 0 strconv.ParseInt: parsing "0xFF": invalid syntax
num, err = strconv.ParseInt("FF", 16, 0)
fmt.Println(num, err) // 255 <nil>
num, err = strconv.ParseInt("0xFF", 0, 0)
fmt.Println(num, err) // 255 <nil>
}
字符串解析为无符号整数 ParseUint
// ParseUint 类似 ParseInt 但不接受正负号，用于无符号整型
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
✏️ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
num, err := strconv.ParseUint("FF", 16, 8)
fmt.Println(num, err) // 255 <nil>
}
字符串解析为浮点数 ParseFloat
// 将字符串解析为浮点数，如果 s 符合语法规则，会返回一个最为接近 s 表示值得浮点数（IEEE754 规范舍入）
// bitSize 指定解析结果的浮点数类型，32 是 float32，64 是 float64
// 返回值 err 是 *NumErr 类型的，语法有误时，err.Error = ErrSyntax；结果超出表示范围时，返回值 f 为 ±Inf，err.Error= ErrRange
func ParseFloat(s string, bitSize int) (f float64, err error)
📚 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
s := "0.12345678901234567890"
f, err := strconv.ParseFloat(s, 32)
fmt.Println(f, err) // 0.12345679104328156 <nil>
fmt.Println(float32(f), err) // 0.12345679 <nil>
f, err = strconv.ParseFloat(s, 64)
fmt.Println(f, err) // 0.12345678901234568 <nil>
}
Format 类型
布尔值转换为字符串 FormatBool
// 根据 b 的值返回字符串 "true" 或 "false"
func FormatBool(b bool) string
✌ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
fmt.Printf("%q\n", strconv.FormatBool(0 < 1)) // "true"
fmt.Printf("%q\n", strconv.FormatBool(0 > 1)) // "false"
}
有符号整数转换为字符串 FormatInt
// 将有符号整数转换为 base 进制的字符串。base 必须在 2 到 36 之间，结果中会使用到小写字母 'a' 到 'z'
func FormatInt(i int64, base int) string
✍ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
i := int64(-2048)
fmt.Printf("%q\n", strconv.FormatInt(i, 2)) // "-100000000000"
fmt.Printf("%q\n", strconv.FormatInt(i, 8)) // "-4000"
fmt.Printf("%q\n", strconv.FormatInt(i, 10)) // "-2048"
fmt.Printf("%q\n", strconv.FormatInt(i, 16)) // "-800"
fmt.Printf("%q\n", strconv.FormatInt(i, 36)) // "-1kw"
}
无符号整数转换为字符串 FormatUint
// FormatInt 的无符号整数版本
func FormatUint(i uint64, base int) string
✍ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
i := uint64(2048)
fmt.Printf("%q\n", strconv.FormatUint(i, 2)) // "100000000000"
fmt.Printf("%q\n", strconv.FormatUint(i, 8)) // "4000"
fmt.Printf("%q\n", strconv.FormatUint(i, 10)) // "2048"
fmt.Printf("%q\n", strconv.FormatUint(i, 16)) // "800"
fmt.Printf("%q\n", strconv.FormatUint(i, 36)) // "1kw"
}
浮点数转换为字符串 FormatFloat
// 将浮点数 f 转换为字符串，bitSize 表示 f 的来源类型（32：float32、64：float64），会据此进行舍入。
// 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
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
💡 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
f := 100.12345678901234567890123456789
fmt.Println(strconv.FormatFloat(f, 'b', 5, 32)) // 13123382p-17
fmt.Println(strconv.FormatFloat(f, 'e', 5, 32)) // 1.00123e+02
fmt.Println(strconv.FormatFloat(f, 'E', 5, 32)) // 1.00123E+02
fmt.Println(strconv.FormatFloat(f, 'f', 5, 32)) // 100.12346
fmt.Println(strconv.FormatFloat(f, 'g', 5, 32)) // 100.12
fmt.Println(strconv.FormatFloat(f, 'G', 5, 32)) // 100.12
fmt.Println(strconv.FormatFloat(f, 'b', 30, 32)) // 13123382p-17
fmt.Println(strconv.FormatFloat(f, 'e', 30, 32)) // 1.001234588623046875000000000000e+02
fmt.Println(strconv.FormatFloat(f, 'E', 30, 32)) // 1.001234588623046875000000000000E+02
fmt.Println(strconv.FormatFloat(f, 'f', 30, 32)) // 100.123458862304687500000000000000
fmt.Println(strconv.FormatFloat(f, 'g', 30, 32)) // 100.1234588623046875
fmt.Println(strconv.FormatFloat(f, 'G', 30, 32)) // 100.1234588623046875
fmt.Println(strconv.FormatFloat(f, 'g', -1, 32)) // 100.12346
}
string 和 int 互相转换
字符串解析为整数 Atoi
// 将字符串解析为整数，是 ParseInt(s, 10, 0) 的简写
func Atoi(s string) (i int, err error)
☕️ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
// 64 位的计算机
num, err := strconv.Atoi("9223372036854775807")
fmt.Println(num, err) // 9223372036854775807 <nil>
num, err = strconv.Atoi("9223372036854775808")
fmt.Println(num, err) // 9223372036854775807 strconv.Atoi: parsing "9223372036854775808": value out of range
}
整数转换为字符串 Itoa
// 将整数转换为字符串，是 FormatInt(i, 10) 的简写
func Itoa(i int) string
⭐️ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
fmt.Println(strconv.Itoa(-2048)) // -2048
fmt.Println(strconv.Itoa(2048)) // 2048
}
其它函数
判断字符是否可显示 isPrint
// 判断字符 r 是否是一个可显示的字符
func IsPrint(r rune) bool
✏️ 示例代码
package main
import (
"fmt"
"strconv"
)
func main() {
fmt.Println(strconv.IsPrint('a')) // true
fmt.Println(strconv.IsPrint('好')) // true
fmt.Println(strconv.IsPrint(' ')) // true
fmt.Println(strconv.IsPrint('\t')) // false
fmt.Println(strconv.IsPrint('\n')) // false
}
