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

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

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

作用：
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,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, 32)
    fmt.Printf("%T,s32,s32)
    s64 := strconv.FormatFloat(v_float, 64)
    fmt.Printf("%T,s64,s64)

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

    v_uint := uint64(42)
    s10 = strconv.FormatUint(v_uint,s10)
    s16 = strconv.FormatUint(v_uint,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,bitSize int) (uint64,error)

应用例子：

package main

import (
    "fmt"
    "strconv"
)

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

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

    v32_int := "-354634382"
    if s,err := strconv.ParseInt(v32_int, 10, 16,s)
    }

    v64_int := "-3546343826724305832"
    if s,err := strconv.ParseInt(v64_int,s)
    }

    v_uint := "42"
    if s,err := strconv.ParseUint(v_uint,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)
    }

    fmt.Println()
    i := 10
    s := strconv.Itoa(i)
    fmt.Printf("%T,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)
}

原文链接：https://www.f2er.com/go/188214.html

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

猜你在找的Go相关文章