Golang 基础库之Strconv
Strconv
参考资料：
http://c.biancheng.net/view/vip_7305.html
https://vimsky.com/examples/list/code-usage-page-1.html
标准库中文文档：
https://studygolang.com/pkgdoc
- strconv包实现了基本数据类型和其字符串表示的相互转换。
实现了基本数据类型与其字符串表示的转换，主要有以下常用函数：
1. Atoi()
等价于ParseInt（s，10，0）;
两个返回值
- int 类型：转换结果
- error类型：错误信息
// Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
func Atoi(s string) (int, error)
func tAtoi() {
var s string = "100"
i, err := strconv.Atoi(s)
if err != nil {
fmt.Println("can't convert to int!,", err)
} else {
fmt.Printf("type:%T value:%#v\n", i, i)
}
}
//结果
type:int value:100
//转换失败：s="10a0"
can't convert to int!, strconv.Atoi: parsing "10a0": invalid syntax
2. Itoa()
等价于FormatInt(int64(i), 10)；
只有一个结果返回值
// Itoa is equivalent to FormatInt(int64(i), 10).
func Itoa(i int) string {
return FormatInt(int64(i), 10)
}
func tItoA() {
var i int = 100
s := strconv.Itoa(i)
fmt.Printf("type:%T value:%#v\n", s, s)
}
//结果
type:string value:"100"
3. Parse系列函数
Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseInt()、ParseUint()、ParseFloat()。
3.1 ParseBool()
返回字符串表示的bool值。它接受 “1”, “t”, “T”, “true”, “TRUE”, “True”,“0”, “f”, “F”, “false”, “FALSE”, “False”；否则返回错误。
// ParseBool returns the boolean value represented by the string.
// It accepts 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False.
// Any other value returns an error.
func ParseBool(str string) (bool, error) {
switch str {
case "1", "t", "T", "true", "TRUE", "True":
return true, nil
case "0", "f", "F", "false", "FALSE", "False":
return false, nil
}
return false, syntaxError("ParseBool", str)
}
3.2 ParseInt()
- 返回字符串表示的整数值，接受正负号。
- base指定进制（2到36），如果base为0，则会从字符串前置判断，”ob“表示2进制，”0”或”0o“是8进制，否则是10进制，”0x”是16进制，否则为十进制；
- bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64，如果bitSize低于0或高于64，返回错误；
- 返回的err是 *NumErr 类型的，如果语法有误，err.Error = ErrSyntax；如果结果超出类型范围err.Error = ErrRange。
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func tParseInt() {
str := "-11"
i, err := strconv.ParseInt(str, 10, 0)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("type:%T value:%#v\n", i, i)
}
i2, err2 := strconv.ParseInt(str, 8, 0)//str是8进制的，结果永远是10进制的结果
if err != nil {
fmt.Println(err2)
} else {
fmt.Printf("type:%T value:%#v\n", i2, i2)
}
}
//结果
type:int64 value:-11
type:int64 value:-9
3.3 ParseUint()
- ParseUint() 函数的功能类似于 ParseInt() 函数，但 ParseUint() 函数不接受正负号，用于无符号整型，函数签名如下：
// ParseUint is like ParseInt but for unsigned numbers.
//
// A sign prefix is not permitted.
func ParseUint(s string, base int, bitSize int) (uint64, error)
3.4 ParseFloat()
- ParseFloat将字符串s转换为浮点数，精度由bitSize指定：32表示float32，64表示float64。
- 当bitSize＝32时，结果的类型仍然是float64，但它可以转换为float32而不改变其值。
- ParseFloat接受10进制和16六进制浮点数语法
- 如果 s 合乎浮点数语法规则，函数会返回最为接近 s 表示值的一个浮点数（使用 IEEE754 规范舍入）。
- （解析十六进制浮点值时，只有当十六进制表示形式中的位多于尾数时，才会进行四舍五入。）
- 返回值 err 是 *NumErr 类型的，如果语法有误 err.Error=ErrSyntax，如果返回值超出表示范围，返回值 f 为 ±Inf，err.Error= ErrRange。
func ParseFloat(s string, bitSize int) (float64, error) {
f, n, err := parseFloatPrefix(s, bitSize)
if n != len(s) && (err == nil || err.(*NumError).Err != ErrSyntax) {
return 0, syntaxError(fnParseFloat, s)
}
return f, err
}
func tParseFloat() {
str := "3.1415926"
fl, err := strconv.ParseFloat(str, 64)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("type:%T value:%#v\n", fl, fl)
}
{
str := "NaN"
fl, err := strconv.ParseFloat(str, 64)
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("type:%T value:%#v\n", fl, fl)
}
}
}
//结果
type:float64 value:3.1415926
type:float64 value:NaN
4. Format系列函数
- Format 系列函数实现了将给定类型数据格式化为字符串类型的功能，其中包括 FormatBool()、FormatInt()、FormatUint()、FormatFloat()。
4.1 FormatBool()
- 根据b的值，返回字符串类型的"true"或者"false"
// FormatBool returns "true" or "false" according to the value of b.
func FormatBool(b bool) string {
if b {
return "true"
}
return "false"
}
4.2 FormatInt()
- FormatInt返回给定base i的字符串表示形式， 2<=base<=36。
// FormatInt returns the string representation of i in the given base,
// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
// for digit values >= 10.
func FormatInt(i int64, base int) string {
if fastSmalls && 0 <= i && i < nSmalls && base == 10 {
return small(int(i))
}
_, s := formatBits(nil, uint64(i), base, i < 0, false)
return s
}
func tFormatInt() {
var i int64 = 10
s := strconv.FormatInt(i, 2)
fmt.Printf("type:%T value:%#v\n", s, s)
{
s := strconv.FormatInt(i, 16)
fmt.Printf("type:%T value:%#v\n", s, s)
}
}
//结果
type:string value:"1010"
type:string value:"a"
4.3 FormatUint()
- 与FormatInt()类似
// FormatUint returns the string representation of i in the given base,
// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
// for digit values >= 10.
func FormatUint(i uint64, base int) string {
if fastSmalls && i < nSmalls && base == 10 {
return small(int(i))
}
_, s := formatBits(nil, i, base, false, false)
return s
}
4.4 FormatFloat()
- FormatFloat根据格式fmt和精度prec将浮点数f转换为字符串。
- fmt值如下：
- ‘b’ (-ddddp±ddd, a binary exponent) 二进制指数
- ‘e’ (-d.dddde±dd, a decimal exponent) 十进制指数
- ‘E’ (-d.ddddE±dd, a decimal exponent) 十进制指数
- ‘f’ (-ddd.dddd, no exponent) 无指数
- ‘g’ (‘e’ for large exponents, ‘f’ otherwise) 指数很大时，同’e’，否则同’f’
- ‘G’ (‘E’ for large exponents, ‘f’ otherwise) 指数很大时，同’E’，否则同’f’
- ‘x’ (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent) 十六进制小数和二进制指数
- ‘X’ (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent) 十六进制小数和二进制指数
- prec：精度prec，由’e’、‘E’、‘f’、‘g’、‘G’、'x’和’X’格式打印的位数（不包括指数）控制。
- 对于“e”、“E”、“f”、“x”和“X”，它是小数点后的位数
- 对于“g”和“G”，是最大有效位数（去掉尾随的零）
- 如果 prec 为 -1，使用必要的最小位数，这样ParseFloat将精确返回f
- fmt值如下：
- bitSize 表示参数 f 的来源类型（32 表示 float32、64 表示 float64），会据此进行舍入
func FormatFloat(f float64, fmt byte, prec, bitSize int) string {
return string(genericFtoa(make([]byte, 0, max(prec+4, 24)), f, fmt, prec, bitSize))
}
func tFormatFloat() {
var num float64 = 123.1415
strb := strconv.FormatFloat(num, 'b', -1, 64)
fmt.Printf("strb type:%T,value:%v\n ", strb, strb)
stre := strconv.FormatFloat(num, 'e', 7, 64)
fmt.Printf("stre type:%T,value:%v\n ", stre, stre)
strE := strconv.FormatFloat(num, 'E', 6, 64)
fmt.Printf("strE type:%T,value:%v\n ", strE, strE)
strf := strconv.FormatFloat(num, 'f', -1, 64)
fmt.Printf("strf type:%T,value:%v\n ", strf, strf)
strg := strconv.FormatFloat(num, 'g', 7, 64)
fmt.Printf("strg type:%T,value:%v\n ", strg, strg)
strG := strconv.FormatFloat(num, 'G', 6, 64)
fmt.Printf("strG type:%T,value:%v\n ", strG, strG)
strx := strconv.FormatFloat(num, 'x', 7, 64)
fmt.Printf("strx type:%T,value:%v\n ", strx, strx)
strX := strconv.FormatFloat(num, 'X', 6, 64)
fmt.Printf("strX type:%T,value:%v\n ", strX, strX)
}
//结果
strb type:string,value:8665312711153811p-46
stre type:string,value:1.2314150e+02
strE type:string,value:1.231415E+02
strf type:string,value:123.1415
strg type:string,value:123.1415
strG type:string,value:123.141
strx type:string,value:0x1.ec90e56p+06
strX type:string,value:0X1.EC90E5P+06
5. Append系列函数
- Append 系列函数和 Format 系列函数的使用方法类似，只不过是将转换后的结果追加到一个切片中。
- 包含了AppendBool()、AppendInt()、AppendUint()、AppendFloat()等函数。
下面举了一个AppendInt()的例子
// AppendInt appends the string form of the integer i,
// as generated by FormatInt, to dst and returns the extended buffer.
func AppendInt(dst []byte, i int64, base int) []byte
func tAppendInt() {
// 声明一个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
6. IsPrint
- 返回一个字符是否是可打印的，和unicode.IsPrint一样，r必须是：字母（广义）、数字、标点、符号、ASCII空格。
func IsPrint(r rune) bool
func main() {
fmt.Println(strconv.IsPrint('a'))
fmt.Println(strconv.IsPrint('\n'))
fmt.Println(strconv.IsPrint('♥'))
}
//结果
true
false
true
7. IsGraphic
- 用于检查符文是否被 Unicode 定义为 Graphic。此类字符包括字母、标记、数字、标点符号、符号和空格，来自类别 L、M、N、 P、S 和 Z。
// IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such
// characters include letters, marks, numbers, punctuation, symbols, and
// spaces, from categories L, M, N, P, S, and Zs.
func IsGraphic(r rune) bool
func main() {
fmt.Println(strconv.IsGraphic('a'))
fmt.Println(strconv.IsGraphic('\n'))
fmt.Println(strconv.IsGraphic('♥'))
}
//结果
true
false
true
8. Quote系列函数
- Quote系列函数
8.1 Quote()
- 返回字符串s在go语法下的双引号字面值表示，控制字符、不可打印字符会进行转义。（如\t，\n，\xFF，\u0100）
// Quote returns a double-quoted Go string literal representing s. The
// returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
// control characters and non-printable characters as defined by
// IsPrint.
func Quote(s string) string {
return quoteWith(s, '"', false, false)
}
func main() {
fmt.Println(strconv.Quote("Hello World!"))
fmt.Println(strconv.Quote(`" Hello
World! "`))
}
//结果
"Hellow World!"
"\" Hello\n\t World! \""
8.2 QuoteRune()
- 返回字符r在go语法下的单引号字面值表示，控制字符、不可打印字符会进行转义。（如\t，\n，\xFF，\u0100）
- 如果r的值不再unicode码值范围内，则返回U+FFFD
- 参数r的类型为rune，rune是类型int32的别名，用来代表字符值。
- 可以使用rune统计字符串长度len([]rune(”Golang编程!“)) //输出9 而len(“Golang编程!”)输出的是13，一个中文字符占3个字节。
// QuoteRune returns a single-quoted Go character literal representing the
// rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100)
// for control characters and non-printable characters as defined by IsPrint.
// If r is not a valid Unicode code point, it is interpreted as the Unicode
// replacement character U+FFFD.
func QuoteRune(r rune) string {
return quoteRuneWith(r, '\'', false, false)
}
func main() {
if strconv.IsPrint(rune(65)) {
fmt.Println(strconv.QuoteRune(rune(65))) //A
}
if strconv.IsPrint(rune(10)) {
fmt.Println(strconv.QuoteRune(rune(10))) //换行
}
fmt.Println(strconv.QuoteRune('♥'))
fmt.Println(strconv.QuoteRune('s'))
}
//结果
'A'
'♥'
's'
//单独执行fmt.Println(strconv.QuoteRune(rune(10)))结果
'\n'
8.3 QuoteRuneToASCII()
- 返回字符r在go语法下的单引号字面值表示，控制字符、不可打印字符、非ASCII字符会进行转义。
- 如果r的值不再unicode码值范围内，则返回U+FFFD
func QuoteRuneToASCII(r rune) string {
return quoteRuneWith(r, '\'', true, false)
}
func main() {
if strconv.IsPrint(rune(65)) {
fmt.Println(strconv.QuoteRuneToASCII(rune(65))) //A
}
if strconv.IsPrint(rune(10)) {
fmt.Println(strconv.QuoteRuneToASCII(rune(10))) //换行
}
fmt.Println(strconv.QuoteRuneToASCII('♥'))
fmt.Println(strconv.QuoteRuneToASCII('s'))
fmt.Println(strconv.QuoteRuneToASCII(rune(65555555)))
}
//结果
'A'
'\u2665'
's'
'\ufffd'
//持续更新…