Go语言学习之strconv包(The way to go)

生命不止，继续 go go go !!!

今天跟大家一起分享strconv包，strconv是golang用来做数据类型转换的一个库。

文档地址：

https://golang.org/pkg/strconv/

作用：

Package strconv implements conversions to and from string representations of basic data types.

Package strconv

strconv为我们提供的方法：

1.Append类型的方法

将各种类型转换为字符串后追加到 dst 尾部。

func AppendInt(dst []byte, i int64, base int) []byte
func AppendUint(dst []byte, i uint64, base int) []byte
func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte
func AppendBool(dst []byte, b bool) []byte

应用例子：

package main

import (
"fmt"
"strconv"
)

func main() {
b := []byte("bool:")
b = strconv.AppendBool(b, true)
fmt.Println(string(b))

b32 := []byte("float32:")
b32 = strconv.AppendFloat(b32, 3.1415926535, 'E', -1, 32)
fmt.Println(string(b32))

b10 := []byte("int (base 10):")
b10 = strconv.AppendInt(b10, -42, 10)
fmt.Println(string(b10))

b16 := []byte("uint (base 16):")
b16 = strconv.AppendUint(b16, 42, 16)
fmt.Println(string(b16))
}

输出：

bool:true

float32:3.1415927E+00

int (base 10):-42

uint (base 16):2a

将各种类型转换为带引号字符串后追加到 dst 尾部。

func AppendQuote(dst []byte, s string) []byte
func AppendQuoteToASCII(dst []byte, s string) []byte
func AppendQuoteToGraphic(dst []byte, s string) []byte
func AppendQuoteRune(dst []byte, r rune) []byte
func AppendQuoteRuneToASCII(dst []byte, r rune) []byte
func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte

应用例子：

package main

import (
"fmt"
"strconv"
)

func main() {
b := []byte("quote:")
b = strconv.AppendQuote(b, `"Fran & Freddie's Diner"`)
fmt.Println(string(b))

b = []byte("rune:")
b = strconv.AppendQuoteRune(b, '☺')
fmt.Println(string(b))

b = []byte("rune (ascii):")
b = strconv.AppendQuoteRuneToASCII(b, '☺')
fmt.Println(string(b))

b = []byte("quote (ascii):")
b = strconv.AppendQuoteToASCII(b, `"Fran & Freddie's Diner"`)
fmt.Println(string(b))
}

输出：

quote:”\”Fran & Freddie’s Diner\””

rune:’☺’

rune (ascii):’\u263a’

quote (ascii):”\”Fran & Freddie’s Diner\”“

2.Format类型的方法

将布尔值转换为字符串 true 或 false

func FormatBool(b bool) string

将浮点数 f 转换为字符串形式

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

f：要转换的浮点数

fmt：格式标记（b、e、E、f、g、G）

prec：精度（数字部分的长度，不包括指数部分）

bitSize：指定浮点类型（32:float32、64:float64），结果会据此进行舍入。

格式标记：

‘b’ (-ddddp±ddd，二进制指数)

‘e’ (-d.dddde±dd，十进制指数)

‘E’ (-d.ddddE±dd，十进制指数)

‘f’ (-ddd.dddd，没有指数)

‘g’ (‘e’:大指数，’f’:其它情况)

‘G’ (‘E’:大指数，’f’:其它情况)

如果格式标记为 ‘e’，’E’和’f’，则 prec 表示小数点后的数字位数

如果格式标记为 ‘g’，’G’，则 prec 表示总的数字位数（整数部分+小数部分）

参考格式化输入输出中的旗标和精度说明

将整数转换为字符串形式。base 表示转换进制，取值在 2 到 36 之间。

结果中大于 10 的数字用小写字母 a - z 表示。

func FormatInt(i int64, base int) string

func FormatUint(i uint64, base int) string

应用例子：

package main

import (
"fmt"
"strconv"
)

func main() {
v := true
s := strconv.FormatBool(v)
fmt.Printf("%T, %v\n", s, s)

v_float := 3.1415926535
s32 := strconv.FormatFloat(v_float, 'E', -1, 32)
fmt.Printf("%T, %v\n", s32, s32)
s64 := strconv.FormatFloat(v_float, 'E', -1, 64)
fmt.Printf("%T, %v\n", s64, s64)

v_int := int64(-42)
s10 := strconv.FormatInt(v_int, 10)
fmt.Printf("%T, %v\n", s10, s10)
s16 := strconv.FormatInt(v_int, 16)
fmt.Printf("%T, %v\n", s16, s16)

v_uint := uint64(42)
s10 = strconv.FormatUint(v_uint, 10)
fmt.Printf("%T, %v\n", s10, s10)
s16 = strconv.FormatUint(v_uint, 16)
fmt.Printf("%T, %v\n", s16, s16)
}

输出：

string, true

string, 3.1415927E+00

string, 3.1415926535E+00

string, -42

string, -2a

string, 42

string, 2a

3.Parse类型的方法

将字符串转换为布尔值

它接受真值：1, t, T, TRUE, true, True

它接受假值：0, f, F, FALSE, false, False

其它任何值都返回一个错误。

func ParseBool(str string) (bool, error)

将字符串解析为浮点数，使用 IEEE754 规范进行舍入。

bigSize 取值有 32 和 64 两种，表示转换结果的精度。

如果有语法错误，则 err.Error = ErrSyntax

如果结果超出范围，则返回 ±Inf，err.Error = ErrRange

func ParseFloat(s string, bitSize int) (float64, error)

将字符串解析为整数，ParseInt 支持正负号，ParseUint 不支持正负号。

base 表示进位制（2 到 36），如果 base 为 0，则根据字符串前缀判断，

前缀 0x 表示 16 进制，前缀 0 表示 8 进制，否则是 10 进制。

bitSize 表示结果的位宽（包括符号位），0 表示最大位宽。

func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)

应用例子：

package main

import (
"fmt"
"strconv"
)

func main() {
v := "true"
if s, err := strconv.ParseBool(v); err == nil {
fmt.Printf("%T, %v\n", s, s)
}

v_float := "3.1415926535"
if s, err := strconv.ParseFloat(v_float, 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat(v_float, 64); err == nil {
fmt.Printf("%T, %v\n", s, s)
}

v32_int := "-354634382"
if s, err := strconv.ParseInt(v32_int, 10, 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseInt(v32_int, 16, 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}

v64_int := "-3546343826724305832"
if s, err := strconv.ParseInt(v64_int, 10, 64); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseInt(v64_int, 16, 64); err == nil {
fmt.Printf("%T, %v\n", s, s)
}

v_uint := "42"
if s, err := strconv.ParseUint(v_uint, 10, 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseUint(v_uint, 10, 64); err == nil {
fmt.Printf("%T, %v\n", s, s)
}

}

输出：

bool, true

float64, 3.1415927410125732

float64, 3.1415926535

int64, -354634382

int64, -3546343826724305832

uint64, 42

uint64, 42

4.Quote类型的方法

将 s 转换为双引号字符串

func Quote(s string) string

功能同上，非 ASCII 字符和不可打印字符会被转义

func QuoteToASCII(s string) string

功能同上，非图形字符会被转义

func QuoteToGraphic(s string) string

将 r 转换为单引号字符

func QuoteRune(r rune) string

功能同上，非 ASCII 字符和不可打印字符会被转义

func QuoteRuneToASCII(r rune) string

功能同上，非图形字符会被转义

func QuoteRuneToGraphic(r rune) string

应用例子：

package main

import (
"fmt"
"strconv"
)

func main() {
s := strconv.Quote(`"Fran & Freddie's Diner ☺"`)
fmt.Println(s)

s = strconv.QuoteRune('☺')
fmt.Println(s)

s = strconv.QuoteRuneToASCII('☺')
fmt.Println(s)

s = strconv.QuoteToASCII(`"Fran & Freddie's Diner   ☺"`)
fmt.Println(s)
}

输出：

“\”Fran & Freddie’s Diner\t☺\””

‘☺’

‘\u263a’

“\”Fran & Freddie’s Diner\t\u263a\”“

其他

将整数转换为十进制字符串形式（即：FormatInt(i, 10) 的简写）

func Itoa(i int) string

将字符串转换为十进制整数，即：ParseInt(s, 10, 0) 的简写）

func Atoi(s string) (int, error)

应用例子：

package main

import (
"fmt"
"strconv"
)

func main() {
v := "10"
if s, err := strconv.Atoi(v); err == nil {
fmt.Printf("%T, %v", s, s)
}

fmt.Println()
i := 10
s := strconv.Itoa(i)
fmt.Printf("%T, %v\n", s, s)
}

输出：

int, 10

string, 10

判断字符串是否可以不被修改的表示为一个单行的反引号字符串。

字符串中不能含有控制字符（除了 \t）和“反引号”字符，否则返回 false

func CanBackquote(s string) bool

应用例子：

package main

import (
"fmt"
"strconv"
)

func main() {
fmt.Println(strconv.CanBackquote("Fran & Freddie's Diner ☺"))
fmt.Println(strconv.CanBackquote("`can't backquote this`"))
}

判断 r 是否为可打印字符

可否打印并不是你想象的那样，比如空格可以打印，而\t则不能打印

func IsPrint(r rune) bool

应用例子：

package main

import (
"fmt"
"strconv"
)

func main() {
c := strconv.IsPrint('\u263a')
fmt.Println(c)

bel := strconv.IsPrint('\007')
fmt.Println(bel)
}