Golang 包-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转其它类型可能会失败，所以这些函数都有第二个返回值表示是否转换成功
• FormatTP类函数将其它类型转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()

// func Itoa(i int) string
// Itoa等效于FormatInt（int64（i），10）。int型转换为字符串
iItoa := 10
sItoa := strconv.Itoa(iItoa)
fmt.Printf("%T,%v\n", sItoa, sItoa) //string,10
// Itoa(): int -> string
println("a" + strconv.Itoa(32))  // a32

2.string转换为int：Atoi()

func Atoi(s string) (int, error)

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

// func Atoi(s string) (int,error)
// Atoi等效于ParseInt（s，10，0），转换为int类型。
vAtoi := "10"
if s, err := strconv.Atoi(vAtoi); err == nil {
    fmt.Printf("%T,%v\n", s, s) //int,10
}
// 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)

• 将字符串解析为整数，ParseInt 支持正负号，ParseUint 不支持正负号。
• base 表示进位制（2 到 36），如果 base 为 0，则根据字符串前缀判断，
• 前缀 0x 表示 16 进制，前缀 0 表示 8 进制，否则是 10 进制。
• bitSize 表示结果的位宽（包括符号位），0 表示最大位宽。

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。

FormatBool()

// 将布尔值转换为字符串 true 或 false
func FormatBool(b bool) string
// 将字符串转换为布尔值
// 它接受真值：1, t, T, TRUE, true, True
// 它接受假值：0, f, F, FALSE, false, False
// 其它任何值都返回一个错误。
func ParseBool(str string) (bool, error)

FormatFloat()参数众多：

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

• f：要转换的浮点数
• 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’，则prec 表示小数点后的数字个数；
  • 对’g’、’G’，则 prec 表示总的数字位数（整数部分+小数部分）；
  • 如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。
• bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

// 将字符串解析为浮点数，使用 IEEE754 规范进行舍入。
// bigSize 取值有 32 和 64 两种，表示转换结果的精度。
// 如果有语法错误，则 err.Error = ErrSyntax
// 如果结果超出范围，则返回 ±Inf，err.Error = ErrRange

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

Quote类函数

// 将 s 转换为双引号字符串
func Quote(s string) string
// 功能同上，非 ASCII 字符和不可打印字符会被转义
func QuoteToASCII(s string) string
// 功能同上，非图形字符会被转义
func QuoteToGraphic(s string) string
------------------------------
// 示例
func main() {
    s := "Hello\t世界！\n"
    fmt.Println(s)                         // Hello    世界！（换行）
    fmt.Println(strconv.Quote(s))          // "Hello\t世界！\n"
    fmt.Println(strconv.QuoteToASCII(s))   // "Hello\t\u4e16\u754c\uff01\n"
    fmt.Println(strconv.QuoteToGraphic(s)) // "Hello\t世界！\n"
}
------------------------------
// 将 r 转换为单引号字符
func QuoteRune(r rune) string
// 功能同上，非 ASCII 字符和不可打印字符会被转义
func QuoteRuneToASCII(r rune) string
// 功能同上，非图形字符会被转义
func QuoteRuneToGraphic(r rune) string
------------------------------
// Unquote 将“带引号的字符串” s 转换为常规的字符串（不带引号和转义字符）
// s 可以是“单引号”、“双引号”或“反引号”引起来的字符串（包括引号本身）
// 如果 s 是单引号引起来的字符串，则返回该该字符串代表的字符
func Unquote(s string) (string, error)
// UnquoteChar 将带引号字符串（不包含首尾的引号）中的第一个字符“取消转义”并解码
//
// s    ：带引号字符串（不包含首尾的引号）
// quote：字符串使用的“引号符”（用于对字符串中的引号符“取消转义”）
//
// value    ：解码后的字符
// multibyte：value 是否为多字节字符
// tail     ：字符串 s 解码后的剩余部分
// error    ：返回 s 中是否存在语法错误
//
// 参数 quote 为“引号符”
// 如果设置为单引号，则 s 中允许出现 \'、" 字符，不允许出现单独的 ' 字符
// 如果设置为双引号，则 s 中允许出现 \"、' 字符，不允许出现单独的 " 字符
// 如果设置为 0，则不允许出现 \' 或 \" 字符，但可以出现单独的 ' 或 " 字符
func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)
------------------------------
// 示例
func main() {
    s1 := "`Hello    世界！`"                 // 解析反引号字符串
    s2 := `"Hello\t\u4e16\u754c\uff01"` // 解析双引号字符串
    fmt.Println(strconv.Unquote(s1))    // Hello    世界！ <nil>
    fmt.Println(strconv.Unquote(s2))    // Hello    世界！ <nil>
    fmt.Println()
    fmt.Println(strconv.UnquoteChar(`\u4e16\u754c\uff01`, 0))
    // 19990 true \u754c\uff01 <nil>
    fmt.Println(strconv.UnquoteChar(`\"abc\"`, '"'))
    // 34 false abc\" <nil>
}

官网示例

package main
import (
    "fmt"
    "log"
    "strconv"
)
func main() {
    // 1.func AppendBool
    //func AppendBool(dst []byte, b bool) []byte
    // AppendBool根据b的值将“ true”或“ false”追加到dst并返回扩展缓冲区。
    b := []byte("bool:")
    b = strconv.AppendBool(b, true)
    fmt.Println(string(b))
    //bool:true
    // 2. func AppendFloat
    // func AppendFloat(dst []byte,f float64, fmt byte, prec, bitSize int) []byte
    // AppendFloat将由FormatFloat生成的浮点数f的字符串形式附加到dst，并返回扩展缓冲区。
    b32 := []byte("float32:")
    b32 = strconv.AppendFloat(b32, 3.1415926535, 'E', -1, 32)
    fmt.Println(string(b32)) //float32:3.1415927E+00
    b64 := []byte("float64:")
    b64 = strconv.AppendFloat(b64, 3.1415926535, 'E', -1, 64)
    fmt.Println(string(b64)) // float64:3.1415926535E+00
    // 3. func AppendInt
    // func AppendInt(dst []byte, i int64, base int) []byte
    // AppendInt将由FormatInt生成的整数i的字符串形式附加到dst，并返回扩展缓冲区。
    b10 := []byte("int (byte 10):")
    b10 = strconv.AppendInt(b10, -42, 10)
    fmt.Println(string(b10)) // int (byte 10):-42
    b16 := []byte("int (byte 16):")
    b16 = strconv.AppendInt(b16, -42, 16)
    fmt.Println(string(b16)) // int (byte 16):-2a
    // 4. func AppendUint
    // func AppendUint(dst []byte,i uint64, base int) []byte
    // AppendUint将由FormatUint生成的无符号整数i的字符串形式附加到dst，然后返回扩展缓冲区。
    bUint10 := []byte("uint (base10):")
    bUint10 = strconv.AppendUint(bUint10, 42, 10)
    fmt.Println(string(bUint10)) //uint (base10):42
    bUint16 := []byte("uint (base16):")
    bUint16 = strconv.AppendUint(bUint16, 42, 10)
    fmt.Println(string(bUint16)) //uint (base16):42
    // 5. func AppendQuote
    // func AppendQuote(dst []byte, s string) []byte
    // AppendQuote将由Quote生成的表示s的双引号Go字符串文字附加到dst并返回扩展缓冲区。
    bQuote := []byte("quote:")
    bQuote = strconv.AppendQuote(bQuote, `"Fran & Freddie's Diner"`)
    fmt.Println(string(bQuote)) // quote:"\"Fran & Freddie's Diner\""
    // 6. func AppendQuoteRune
    // func AppendQuoteRune(dst []byte, r rune) []byte
    // AppendQuoteRune将由QuoteRune生成的表示rune的单引号Go字符文字附加到dst，并返回扩展缓冲区。
    bQuoteRune := []byte("rune:")
    bQuoteRune = strconv.AppendQuoteRune(bQuoteRune, '😊')
    fmt.Println(string(bQuoteRune)) //rune:'😊'
    // 7. func AppendQuoteRuneToASCII
    // func AppendQuoteRuneToASCII(dst []byte,r rune) []byte
    // AppendQuoteRuneToASCII将由QuoteRuneToASCII生成的表示rune的单引号Go字符文字附加到dst，并返回扩展缓冲区。
    bQuoteRuneToASCII := []byte("rune(ascii):")
    bQuoteRuneToASCII = strconv.AppendQuoteRuneToASCII(bQuoteRuneToASCII, '☺')
    fmt.Println(string(bQuoteRuneToASCII)) //rune(ascii):'\u263a'
    // 8. func AppendQuoteRuneToGraphic
    // func AppendQuoteToGraphic(dst []byte, r rune) []byte
    // AppendQuoteToGraphic将由QuoteToGraphic生成的表示s的双引号Go字符串文字附加到dst，并返回扩展缓冲区。
    // 9. func AppendQuoteToASCII
    // func AppendQuoteToASCII(dst []byte, s string) []byte
    bQuoteToASCII := []byte("quote (ascii):")
    bQuoteToASCII = strconv.AppendQuoteToASCII(bQuoteToASCII, `"Fran & Freddie's Diner"`)
    fmt.Println(string(bQuoteToASCII)) //quote (ascii):"\"Fran & Freddie's Diner\""
    // 10. func AppendQuoteToGraphic
    // func AppendQuoteToGraphic(dst []byte, s string) []byte
    // AppendQuoteToGraphic将由QuoteToGraphic生成的表示s的双引号Go字符串文字附加到dst，并返回扩展缓冲区。
    // 11. func Atoi
    // func Atoi(s string) (int,error)
    // Atoi等效于ParseInt（s，10，0），转换为int类型。
    vAtoi := "10"
    if s, err := strconv.Atoi(vAtoi); err == nil {
        fmt.Printf("%T,%v\n", s, s) //int,10
    }
    // 12. func CanBackquote
    // func CanBackquote(s string) bool
    // CanBackquote报告字符串s是否可以不变地表示为单行反引号字符串，且没有制表符以外的控制字符
    fmt.Println(strconv.CanBackquote("Fran & Freddie's Diner ☺")) //true
    fmt.Println(strconv.CanBackquote("`can't backquote this`"))   //false
    // 13. func FormatBool
    // func FormatBool(b bool) string
    // FormatBool根据b的值返回“ true”或“ false”。
    vFormatBool := true
    sFormatBool := strconv.FormatBool(vFormatBool)
    fmt.Printf("%T,%v\n", sFormatBool, sFormatBool)
    // 14. func FormatComplex
    // func FormatComplex(c complex128, fmt byte, prec, bitSize int) string
    // FormatComplex将复数c转换为（a + bi）形式的字符串，其中a和b是实部和虚部，并根据格式fmt和precision prec进行格式化。
    // 格式fmt和precision prec具有与FormatFloat中相同的含义。假设原始结果是从bitSize位的复数值获得的，则对结果进行四舍五入，对于bit64，复数必须为64，而对于128为复数，则必须为128。
    // 15. func FormatFloat
    // func FormatFloat(f float64, fmt byte, prec, bitSize int) string
    // FormatFloat根据fmt和precision prec格式将浮点数f转换为字符串。假设原始结果是从bitSize位的浮点值（float32为32，float64为64）获得的，则对结果进行四舍五入。
    //格式fmt是'b'（-ddddp±ddd，二进制指数），'e'（-d.dddde±dd，十进制指数），'E'（-d.ddddE±dd，十进制指数）之一），'f'（-ddd.dddd，无指数），'g'（大指数为'e'，否则为'f'），'G'（大指数为'E'，否则为'f'），' x'（-0xd.ddddp±ddd，十六进制分数和二进制指数）或'X'（-0Xd.ddddP±ddd，十六进制分数和二进制指数）。
    //精度精度控制以“ e”，“ E”，“ f”，“ g”，“ G”，“ x”和“ X”格式打印的位数（不包括指数）。对于“ e”，“ E”，“ f”，“ x”和“ X”，它是小数点后的位数。对于“ g”和“ G”，它是有效数字的最大数量（删除零位）。特殊精度-1使用必要的最小位数，以使ParseFloat准确返回f。
    vFloat := 3.1415926535
    sFloat32 := strconv.FormatFloat(vFloat, 'E', -1, 32)
    fmt.Printf("%T,%v\n", sFloat32, sFloat32) // string,3.1415927E+00
    sFloat64 := strconv.FormatFloat(vFloat, 'E', -1, 64)
    fmt.Printf("%T,%v\n", sFloat64, sFloat64) // string,3.1415926535E+00
    // 16. func FormInt
    // func FormatInt(i int64,base int) string
    // FormatInt返回给定基数i的字符串表示形式，表示2 <= base <=36。结果使用小写字母'a'到'z'表示数字值> = 10。
    vInt := int64(-42)
    sInt10 := strconv.FormatInt(vInt, 10)
    fmt.Printf("%T,%v\n", sInt10, sInt10) //string,-42
    sInt16 := strconv.FormatInt(vInt, 16)
    fmt.Printf("%T,%v\n", sInt16, sInt16) //string,-2a
    // 17. func FormatUint
    // func FormatUint(i uint64, base int) string
    // FormatUint以2 <= base <= 36的形式返回给定基数i的字符串表示形式。结果使用小写字母'a'到'z'表示数字值> = 10。
    vUint := uint64(42)
    sUint10 := strconv.FormatUint(vUint, 10)
    fmt.Printf("%T,%v\n", sUint10, sUint10) //string,42
    sUint16 := strconv.FormatUint(vUint, 16)
    fmt.Printf("%T,%v\n", sUint16, sUint16) //string,2a
    // 18. func IsGraphic
    // func IsGraphic(r rune) bool
    // IsGraphic报告是否通过Unicode将符文定义为“图形”。此类字符包括字母，标记，数字，标点符号，符号和空格，来自类别L，M，N，P，S和Zs。
    shamrock := strconv.IsGraphic('☘')
    fmt.Println(shamrock) // true
    aIsGraphic := strconv.IsGraphic('a')
    fmt.Println(aIsGraphic) // true
    bel := strconv.IsGraphic('\007')
    fmt.Println(bel) // false
    // 19. func IsPrint
    // func IsPrint(r rune) bool
    // IsPrint报告符文是否定义为Go可打印的符文，其定义与unicode.IsPrint：字母，数字，标点符号，符号和ASCII空间。
    cIsPrint := strconv.IsPrint('\u263a')
    fmt.Println(cIsPrint) // true
    belIsPrint := strconv.IsPrint('\007')
    fmt.Println(belIsPrint) // false
    // 20. func Itoa
    // func Itoa(i int) string
    // Itoa等效于FormatInt（int64（i），10）。int型转换为字符串
    iItoa := 10
    sItoa := strconv.Itoa(iItoa)
    fmt.Printf("%T,%v\n", sItoa, sItoa) //string,10
    // 21. func ParseBool
    // func ParseBool(str string) (bool,error)
    // ParseBool返回由字符串表示的布尔值。它接受1，t，T，TRUE，true，True，0，f，F，FALSE，false，False。其他任何值都将返回错误。
    vParseBool := "true" //bool,true
    //vParseBool := "2"  //strconv.ParseBool: parsing "2": invalid syntax
    if sParseBool, err := strconv.ParseBool(vParseBool); err == nil {
        fmt.Printf("%T,%v\n", sParseBool, sParseBool)
    } else {
        fmt.Println(err)
    }
    // 22. func ParseComplex
    // func ParseComplex(s string,bitSize int) (complex128, error)
    // ParseComplex用bitSize指定的精度将字符串s转换为复数：complex64为64，complex128为128。当bitSize = 64时，结果仍然具有complex128类型，但是可以将其转换为complex64而无需更改其值。
    //
    // s表示的数字必须采用N，Ni或N±Ni的形式，其中N代表ParseFloat识别的浮点数，而i是虚部。如果第二个N是无符号的，则在两个分量之间需要一个+号，如±所示。如果第二个N为NaN，则仅接受+号。表格可以用括号括起来，不能包含任何空格。生成的复数由ParseFloat转换的两个组件组成。
    //
    // ParseComplex返回的错误的具体类型为* NumError，其中包括err.Num = s。
    //
    // 如果s在语法上不正确，则ParseComplex返回err.Err = ErrSyntax。
    //
    // 如果s的语法格式正确，但是任一组件距离给定组件大小的最大浮点数均超过1/2 ULP，则ParseComplex返回err.Err = ErrRange，c =±Inf。
    // 22. func ParseFloat
    // func ParseFloat(s string, bitSize int) (float64,error)
    // ParseFloat使用bitSize指定的精度将字符串s转换为浮点数：float32为32或float64为64。当bitSize = 32时，结果仍为float64类型，但可以将其转换为float32而无需更改其值。
    //
    // ParseFloat接受十进制和十六进制浮点数语法。如果s格式正确且在有效的浮点数附近，则ParseFloat返回使用IEEE754无偏舍入舍入的最接近的浮点数。（仅当十六进制表示中的位数比尾数可容纳的位数多时，才对舍入十六进制浮点值进行四舍五入。）
    //
    // ParseFloat返回的错误的具体类型为* NumError，其中包括err.Num = s。
    //
    // 如果s在语法上不正确，则ParseFloat返回err.Err = ErrSyntax。
    //
    // 如果s的语法格式正确，但与给定大小的最大浮点数相差超过1/2 ULP，则ParseFloat返回f =±Inf，err.Err = ErrRange。
    //
    // ParseFloat将字符串“ NaN”以及（可能带有符号的）字符串“ Inf”和“ Infinity”识别为它们各自的特殊浮点值。匹配时忽略大小写。
    vParseFloat := "3.1415926535"
    if s, err := strconv.ParseFloat(vParseFloat, 32); err == nil {
        fmt.Printf("%T,%v\n", s, s)
    }
    if s, err := strconv.ParseFloat(vParseFloat, 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) //float64, -0
    }
    if s, err := strconv.ParseFloat("+0", 32); err == nil {
        fmt.Printf("%T, %v\n", s, s) //float64, 0
    }
    // 23. func ParseInt
    // func ParseInt(s string, base int, bitSize int) (i int64, err error)
    // ParseInt解析给定基数（0、2到36）和位大小（0到64）中的字符串s，并返回对应的值i。
    //
    //如果base参数为0，则字符串的前缀隐含真实的基数：“ 0b”为2，“ 0”或“ 0o”为8，“ 0x”为16，否则为10。此外，仅对于参数基数0，如Go语法所定义的整数文字一样，允许使用下划线字符。
    //
    //bitSize参数指定结果必须适合的整数类型。位大小0、8、16、32和64分别对应于int，int8，int16，int32和int64。如果bitSize小于0或大于64，则返回错误。
    //
    //ParseInt返回的错误的具体类型为* NumError，其中包括err.Num = s。如果s为空或包含无效数字，则err.Err = ErrSyntax，返回值为0；否则，返回0。如果与s对应的值不能用给定大小的有符号整数表示，则err.Err = ErrRange，并且返回的值是适当的bitSize和sign的最大大小整数。
    vParseInt32 := "-354634382"
    if s, err := strconv.ParseInt(vParseInt32, 10, 32); err == nil {
        fmt.Printf("%T, %v\n", s, s) //int64, -354634382
    }
    if s, err := strconv.ParseInt(vParseInt32, 16, 32); err == nil {
        fmt.Printf("%T, %v\n", s, s)
    } else {
        fmt.Println(err) //strconv.ParseInt: parsing "-354634382": value out of range
    }
    vParseInt64 := "-3546343826724305832"
    if s, err := strconv.ParseInt(vParseInt64, 10, 64); err == nil {
        fmt.Printf("%T, %v\n", s, s) //int64, -3546343826724305832
    }
    if s, err := strconv.ParseInt(vParseInt64, 16, 64); err == nil {
        fmt.Printf("%T, %v\n", s, s)
    } else {
        fmt.Println(err) //strconv.ParseInt: parsing "-3546343826724305832": value out of range
    }
    // 24. func ParseUint
    // func ParseUint(s string, base int, bitSize int) (uint64,error)
    // ParseUint类似于ParseInt，但用于无符号数字。
    vParseUint := "42"
    if s, err := strconv.ParseUint(vParseUint, 10, 32); err == nil {
        fmt.Printf("%T,%v\n", s, s) //uint64,42
    }
    if s, err := strconv.ParseUint(vParseUint, 10, 64); err == nil {
        fmt.Printf("%T,%v\n", s, s) //uint64,42
    }
    // 25. func Quote
    // func Quote(s string) string
    // Quote返回表示s的双引号Go字符串文字。返回的字符串使用Go转义序列（\ t，\ n，\ xFF，\ u0100）来控制字符和IsPrint定义的不可打印字符。
    sQuote := strconv.Quote(`"Fran & Freddie's Diner    ☺"`)
    fmt.Println(sQuote) //"\"Fran & Freddie's Diner\t☺\""
    // 26. func QuoteRune
    // func Quote(r rune) string
    // QuoteRune返回表示符文的单引号Go字符文字。返回的字符串使用Go转义序列（\ t，\ n，\ xFF，\ u0100）来控制字符和IsPrint定义的不可打印字符。
    sQuoteRune := strconv.QuoteRune('☺')
    fmt.Println(sQuoteRune) //'☺'
    // 27. func QuoteRuneToASCII
    // func QuoteRuneToASCII(r rune) string
    // QuoteRuneToASCII返回表示符文的单引号Go字符文字。返回的字符串对IsASCII定义的非ASCII字符和不可打印的字符使用Go转义序列（\ t，\ n，\ xFF，\ u0100）。
    sQuoteRuneToASCII := strconv.QuoteRuneToASCII('☺')
    fmt.Println(sQuoteRuneToASCII) //'☺'
    // 28. func QuoteRuneToGraphic
    // func QuoteRuneToGraphic(r rune) string
    // QuoteRuneToGraphic返回表示符文的单引号Go字符文字。如果符文不是IsGraphic定义的Unicode图形字符，则返回的字符串将使用Go转义序列（\ t，\ n，\ xFF，\ u0100）。
    sQuoteRuneToGraphic := strconv.QuoteRuneToGraphic('☺')
    fmt.Println(sQuoteRuneToGraphic) // '☺'
    sQuoteRuneToGraphic = strconv.QuoteRuneToGraphic('\u263a')
    fmt.Println(sQuoteRuneToGraphic) // '☺'
    sQuoteRuneToGraphic = strconv.QuoteRuneToGraphic('\u000a')
    fmt.Println(sQuoteRuneToGraphic) // '\n'
    sQuoteRuneToGraphic = strconv.QuoteRuneToGraphic('    ') // tab character
    fmt.Println(sQuoteRuneToGraphic)                      // '\t'
    // 29. func QuoteToASCII
    // func QuoteToASCII(s string) string
    // QuoteToASCII返回表示s的双引号Go字符串文字。返回的字符串对IsASCII定义的非ASCII字符和不可打印的字符使用Go转义序列（\ t，\ n，\ xFF，\ u0100）。
    sQuoteToASCII := strconv.QuoteToASCII(`"Fran & Freddie's Diner    ☺"`)
    fmt.Println(sQuoteToASCII) // "\"Fran & Freddie's Diner\t\u263a\""
    // 30. func QuoteToGraphic
    // func QuoteToGraphic(s string) string
    // QuoteToGraphic返回表示s的双引号Go字符串文字。返回的字符串保留IsGraphic定义的Unicode图形字符不变，并且对非图形字符使用Go转义序列（\ t，\ n，\ xFF，\ u0100）。
    sQuoteToGraphic := strconv.QuoteToGraphic("☺")
    fmt.Println(sQuoteToGraphic) // "☺"
    // This string literal contains a tab character.
    sQuoteToGraphic = strconv.QuoteToGraphic("This is a \u263a    \u000a")
    fmt.Println(sQuoteToGraphic) // "This is a ☺\t\n"
    sQuoteToGraphic = strconv.QuoteToGraphic(`" This is a ☺ \n "`)
    fmt.Println(sQuoteToGraphic) // "\" This is a ☺ \\n \""
    // 31. func Unquote
    // func Unquote(s string) (string error)
    // Unquote将s解释为单引号，双引号或反引号的Go字符串文字，并返回s引用的字符串值。（如果s是单引号，则它将是Go字符文字； Unquote返回相应的单字符字符串。）
    sUnquote, err := strconv.Unquote("You can't unquote a string without quotes")
    fmt.Printf("%q, %v\n", sUnquote, err) // "", invalid syntax
    sUnquote, err = strconv.Unquote("\"The string must be either double-quoted\"")
    fmt.Printf("%q, %v\n", sUnquote, err) // "The string must be either double-quoted", <nil>
    sUnquote, err = strconv.Unquote("`or backquoted.`")
    fmt.Printf("%q, %v\n", sUnquote, err)       // "or backquoted.", <nil>
    sUnquote, err = strconv.Unquote("'\u263a'") // single character only allowed in single quotes
    fmt.Printf("%q, %v\n", sUnquote, err)       // "☺", <nil>
    sUnquote, err = strconv.Unquote("'\u2639\u2639'")
    fmt.Printf("%q, %v\n", sUnquote, err) // "", invalid syntax
    // 32. func UnquoteChar
    // func UnquoteChar(s string,quote byte) (value rune, multibyte bool, tail string,err error)
    // UnquoteChar解码转义的字符串或由字符串s表示的字符文字中的第一个字符或字节。它返回四个值：
    // 1）值，即解码后的Unicode代码点或字节值；
    // 2）多字节，一个布尔值，指示解码的字符是否需要多字节UTF-8表示形式；
    // 3）尾部，字符串后字符的其余部分；和
    // 4）如果字符在语法上有效，则错误将为nil。
    // 第二个参数quote指定要解析的文字的类型，因此允许使用转义的引号字符。如果设置为单引号，则允许使用序列\'并禁止未转义的'。如果设置为双引号，则允许使用“”，而不允许使用不转义的“。如果设置为零，则不允许任何转义，并且两个引号字符都显示为不转义。
    vUnquoteChar, mbUnquoteChar, tUnquoteChar, err := strconv.UnquoteChar(`\"Fran & Freddie's Diner\"`, '"')
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("value:", string(vUnquoteChar)) // value: "
    fmt.Println("multibyte:", mbUnquoteChar)    // multibyte: false
    fmt.Println("tail:", tUnquoteChar)          // tail: Fran & Freddie's Diner\"
    // 33. func (*NumError) Error
    // func (e *NumError) Error() string
    // 34. func (*NumError) Unwrap
    // func (e *NumError) Unwrap() error
    // 33.  typeNumError
}

参考：
https://www.cnblogs.com/f-ck-need-u/p/9863915.html
https://www.cnblogs.com/golove/p/3262925.html
https://golang.org/pkg/strconv/#example_AppendQuoteRuneToASCII