go中 -strconv包的使用

strconv 包中的函数和方法

// atob.go

------------------------------------------------------------

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

package main

import (

	"fmt"

	"strconv"

)

func main() {

	fmt.Println(strconv.ParseBool("1"))    // true

	fmt.Println(strconv.ParseBool("t"))    // true

	fmt.Println(strconv.ParseBool("T"))    // true

	fmt.Println(strconv.ParseBool("true")) // true

	fmt.Println(strconv.ParseBool("True")) // true

	fmt.Println(strconv.ParseBool("TRUE")) // true

	fmt.Println(strconv.ParseBool("TRue"))

	// false strconv.ParseBool: parsing "TRue": invalid syntax

	fmt.Println(strconv.ParseBool("0"))     // false

	fmt.Println(strconv.ParseBool("f"))     // false

	fmt.Println(strconv.ParseBool("F"))     // false

	fmt.Println(strconv.ParseBool("false")) // false

	fmt.Println(strconv.ParseBool("False")) // false

	fmt.Println(strconv.ParseBool("FALSE")) // false

	fmt.Println(strconv.ParseBool("FALse"))

	// false strconv.ParseBool: parsing "FAlse": invalid syntax

}

------------------------------------------------------------

// FormatBool 将布尔值转换为字符串 "true" 或 "false"
func FormatBool(b bool) string

func main() {

	fmt.Println(strconv.FormatBool(0 < 1)) // true

	fmt.Println(strconv.FormatBool(0 > 1)) // false

}

------------------------------------------------------------

// AppendBool 将布尔值 b 转换为字符串 "true" 或 "false"
// 然后将结果追加到 dst 的尾部，返回追加后的 []byte
func AppendBool(dst []byte, b bool) []byte

func main() {

	rst := make([]byte, 0)

	rst = strconv.AppendBool(rst, 0 < 1)

	fmt.Printf("%s\n", rst) // true

	rst = strconv.AppendBool(rst, 0 > 1)

	fmt.Printf("%s\n", rst) // truefalse

}

============================================================

// atof.go

------------------------------------------------------------

// ParseFloat 将字符串转换为浮点数
// s：要转换的字符串
// bitSize：指定浮点类型（32:float32、64:float64）
// 如果 s 是合法的格式，而且接近一个浮点值，
// 则返回浮点数的四舍五入值（依据 IEEE754 的四舍五入标准）
// 如果 s 不是合法的格式，则返回“语法错误”
// 如果转换结果超出 bitSize 范围，则返回“超出范围”
func ParseFloat(s string, bitSize int) (f float64, err error)

func main() {

	s := "0.12345678901234567890"

	f, err := strconv.ParseFloat(s, 32)

	fmt.Println(f, err)          // 0.12345679104328156

	fmt.Println(float32(f), err) // 0.12345679

	f, err = strconv.ParseFloat(s, 64)

	fmt.Println(f, err) // 0.12345678901234568

}

============================================================

// atoi.go

------------------------------------------------------------

// ErrRange 表示值超出范围
var ErrRange = errors.New("value out of range")

// ErrSyntax 表示语法不正确
var ErrSyntax = errors.New("invalid syntax")

// NumError 记录转换失败
type NumError struct {
Func string // 失败的函数名(ParseBool, ParseInt, ParseUint, ParseFloat)
Num string // 输入的值
Err error // 失败的原因(ErrRange, ErrSyntax)
}

// int 或 uint 类型的长度(32 或 64)
const IntSize = intSize
const intSize = 32 << uint(^uint(0)>>63)

// 实现 Error 接口，输出错误信息
func (e *NumError) Error() string

------------------------------------------------------------

// ParseInt 将字符串转换为 int 类型
// s：要转换的字符串
// base：进位制（2 进制到 36 进制）
// bitSize：指定整数类型（0:int、8:int8、16:int16、32:int32、64:int64）
// 返回转换后的结果和转换时遇到的错误
// 如果 base 为 0，则根据字符串的前缀判断进位制（0x:16，0:8，其它:10）
func ParseInt(s string, base int, bitSize int) (i int64, err error)

func main() {

	fmt.Println(strconv.ParseInt("123", 10, 8))

	// 123

	fmt.Println(strconv.ParseInt("12345", 10, 8))

	// 127 strconv.ParseInt: parsing "12345": value out of range

	fmt.Println(strconv.ParseInt("2147483647", 10, 0))

	// 2147483647

	fmt.Println(strconv.ParseInt("0xFF", 16, 0))

	// 0 strconv.ParseInt: parsing "0xFF": invalid syntax

	fmt.Println(strconv.ParseInt("FF", 16, 0))

	// 255

	fmt.Println(strconv.ParseInt("0xFF", 0, 0))

	// 255

}

------------------------------------------------------------

// ParseUint 功能同 ParseInt 一样，只不过返回 uint 类型整数
func ParseUint(s string, base int, bitSize int) (n uint64, err error)

func main() {

	fmt.Println(strconv.ParseUint("FF", 16, 8))

	// 255

}

------------------------------------------------------------

// Atoi 相当于 ParseInt(s, 10, 0)
// 通常使用这个函数，而不使用 ParseInt
func Atoi(s string) (i int, err error)

func main() {

	fmt.Println(strconv.Atoi("2147483647"))

	// 2147483647

	fmt.Println(strconv.Atoi("2147483648"))

	// 2147483647 strconv.ParseInt: parsing "2147483648": value out of range

}

============================================================

// ftoa.go

------------------------------------------------------------

// FormatFloat 将浮点数 f 转换为字符串值
// 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 表示总的数字位数（整数部分+小数部分）
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

}

------------------------------------------------------------

// AppendFloat 将浮点数 f 转换为字符串值，并将转换结果追加到 dst 的尾部
// 返回追加后的 []byte
func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte

func main() {

	f := 100.12345678901234567890123456789

	b := make([]byte, 0)

	b = strconv.AppendFloat(b, f, 'f', 5, 32)

	b = append(b, " "...)

	b = strconv.AppendFloat(b, f, 'e', 5, 32)

	fmt.Printf("%s", b) // 100.12346 1.00123e+0

}

============================================================

// itoa.go

------------------------------------------------------------

// FormatUint 将 int 型整数 i 转换为字符串形式
// base：进位制（2 进制到 36 进制）
// 大于 10 进制的数，返回值使用小写字母 'a' 到 'z'
func FormatInt(i int64, base int) string

func main() {

	i := int64(-2048)

	fmt.Println(strconv.FormatInt(i, 2))  // -100000000000

	fmt.Println(strconv.FormatInt(i, 8))  // -4000

	fmt.Println(strconv.FormatInt(i, 10)) // -2048

	fmt.Println(strconv.FormatInt(i, 16)) // -800

	fmt.Println(strconv.FormatInt(i, 36)) // -1kw

}

------------------------------------------------------------

// FormatUint 将 uint 型整数 i 转换为字符串形式
// base：进位制（2 进制到 36 进制）
// 大于 10 进制的数，返回值使用小写字母 'a' 到 'z'
func FormatUint(i uint64, base int) string

func main() {

	i := uint64(2048)

	fmt.Println(strconv.FormatUint(i, 2))  // 100000000000

	fmt.Println(strconv.FormatUint(i, 8))  // 4000

	fmt.Println(strconv.FormatUint(i, 10)) // 2048

	fmt.Println(strconv.FormatUint(i, 16)) // 800

	fmt.Println(strconv.FormatUint(i, 36)) // 1kw

}

------------------------------------------------------------

// Itoa 相当于 FormatInt(i, 10)
func Itoa(i int) string

func main() {

	fmt.Println(strconv.Itoa(-2048)) // -2048

	fmt.Println(strconv.Itoa(2048))  // 2048

}

------------------------------------------------------------

// AppendInt 将 int 型整数 i 转换为字符串形式，并追加到 dst 的尾部
// i：要转换的字符串
// base：进位制
// 返回追加后的 []byte
func AppendInt(dst []byte, i int64, base int) []byte

func main() {

	b := make([]byte, 0)

	b = strconv.AppendInt(b, -2048, 16)

	fmt.Printf("%s", b) // -800

}

------------------------------------------------------------

// AppendUint 将 uint 型整数 i 转换为字符串形式，并追加到 dst 的尾部
// i：要转换的字符串
// base：进位制
// 返回追加后的 []byte
func AppendUint(dst []byte, i uint64, base int) []byte

func main() {
   b := make([]byte, 0)
   b = strconv.AppendUint(b, 2048, 16)
   fmt.Printf("%s", b) // 800
}

============================================================

// quote.go

------------------------------------------------------------

// Quote 将字符串 s 转换为“双引号”引起来的字符串
// 其中的特殊字符将被转换为“转义字符”
// “不可显示的字符”将被转换为“转义字符”
func Quote(s string) string

func main() {

	fmt.Println(strconv.Quote(`C:\Windows`))

	// "C:\\Windows"

}

注：此处是反引号（键盘上１左侧那个按键），而不是单引号

------------------------------------------------------------

// AppendQuote 将字符串 s 转换为“双引号”引起来的字符串，
// 并将结果追加到 dst 的尾部，返回追加后的 []byte
// 其中的特殊字符将被转换为“转义字符”
func AppendQuote(dst []byte, s string) []byte

func main() {

	s := `C:\Windows`

	b := make([]byte, 0)

	b = strconv.AppendQuote(b, s)

	fmt.Printf("%s", b) // "C:\\Windows"

}

------------------------------------------------------------

// QuoteToASCII 将字符串 s 转换为“双引号”引起来的 ASCII 字符串
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func QuoteToASCII(s string) string

func main() {

	fmt.Println(strconv.QuoteToASCII("Hello 世界！"))

	// "Hello \u4e16\u754c\uff01"

}

------------------------------------------------------------

// AppendQuoteToASCII 将字符串 s 转换为“双引号”引起来的 ASCII 字符串，
// 并将结果追加到 dst 的尾部，返回追加后的 []byte
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func AppendQuoteToASCII(dst []byte, s string) []byte

func main() {

	s := "Hello 世界！"

	b := make([]byte, 0)

	b = strconv.AppendQuoteToASCII(b, s)

	fmt.Printf("%s", b) // "Hello \u4e16\u754c\uff01"

}

------------------------------------------------------------

// QuoteRune 将 Unicode 字符转换为“单引号”引起来的字符串
// “特殊字符”将被转换为“转义字符”
func QuoteRune(r rune) string
func main() {
fmt.Println(strconv.QuoteRune('好'))
// '好'
}

注：此处为单引号，而不是反引号，这点要与Quote()使用去分开

------------------------------------------------------------

// AppendQuoteRune 将 Unicode 字符转换为“单引号”引起来的字符串，
// 并将结果追加到 dst 的尾部，返回追加后的 []byte
// “特殊字符”将被转换为“转义字符”
func AppendQuoteRune(dst []byte, r rune) []byte

func main() {

	b := make([]byte, 0)

	b = strconv.AppendQuoteRune(b, '好')

	fmt.Printf("%s", b) // '好'

}

------------------------------------------------------------

// QuoteRuneToASCII 将 Unicode 字符转换为“单引号”引起来的 ASCII 字符串
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func QuoteRuneToASCII(r rune) string

func main() {

	fmt.Println(strconv.QuoteRuneToASCII('好'))

	// '\u597d'

}

------------------------------------------------------------

// AppendQuoteRune 将 Unicode 字符转换为“单引号”引起来的 ASCII 字符串，
// 并将结果追加到 dst 的尾部，返回追加后的 []byte
// “非 ASCII 字符”和“特殊字符”将被转换为“转义字符”
func AppendQuoteRuneToASCII(dst []byte, r rune) []byte

func main() {

	b := make([]byte, 0)

	b = strconv.AppendQuoteRuneToASCII(b, '好')

	fmt.Printf("%s", b) // '\u597d'

}

------------------------------------------------------------

// CanBackquote 判断字符串 s 是否可以表示为一个单行的“反引号”字符串
// 字符串中不能含有控制字符（除了 \t）和“反引号”字符，否则返回 false
func CanBackquote(s string) bool

func main() {

	b := strconv.CanBackquote("C:\\Windows\n")

	fmt.Println(b) // false

	b = strconv.CanBackquote("C:\\Windows\r")

	fmt.Println(b) // false

	b = strconv.CanBackquote("C:\\Windows\f")

	fmt.Println(b) // false

	b = strconv.CanBackquote("C:\\Windows\t")

	fmt.Println(b) // true

	b = strconv.CanBackquote("C:\\`Windows`")

	fmt.Println(b) // false

}

------------------------------------------------------------

// UnquoteChar 将 s 中的第一个字符“取消转义”并解码
//
// s：转义后的字符串
// quote：字符串使用的“引号符”（用于对引号符“取消转义”）
//
// value：解码后的字符
// multibyte：value 是否为多字节字符
// tail：字符串 s 除去 value 后的剩余部分
// error：返回 s 中是否存在语法错误
//
// 参数 quote 为“引号符”
// 如果设置为单引号，则 s 中允许出现 \' 字符，不允许出现单独的 ' 字符
// 如果设置为双引号，则 s 中允许出现 \" 字符，不允许出现单独的 " 字符
// 如果设置为 0，则不允许出现 \' 或 \" 字符，可以出现单独的 ' 或 " 字符
func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)

func main() {

	s := `\"大\\家\\好！\"`

	c, mb, sr, _ := strconv.UnquoteChar(s, '"')

	fmt.Printf("%-3c %v\n", c, mb)

	for ; len(sr) > 0; c, mb, sr, _ = strconv.UnquoteChar(sr, '"') {

		fmt.Printf("%-3c %v\n", c, mb)

	}

	// " false

	// 大 true

	// \ false

	// 家 true

	// \ false

	// 好 true

	// ！ true

}

------------------------------------------------------------

// Unquote 将“带引号的字符串” s 转换为常规的字符串（不带引号和转义字符）
// s 可以是“单引号”、“双引号”或“反引号”引起来的字符串（包括引号本身）
// 如果 s 是单引号引起来的字符串，则返回该该字符串代表的字符
func Unquote(s string) (t string, err error)

func main() {

	sr, err := strconv.Unquote(`"\"大\t家\t好！\""`)

	fmt.Println(sr, err)

	sr, err = strconv.Unquote(`'大家好！'`)

	fmt.Println(sr, err)

	sr, err = strconv.Unquote(`'好'`)

	fmt.Println(sr, err)

	sr, err = strconv.Unquote("`大\\t家\\t好！`")

	fmt.Println(sr, err)

}

------------------------------------------------------------

// IsPrint 判断 Unicode 字符 r 是否是一个可显示的字符
// 可否显示并不是你想象的那样，比如空格可以显示，而\t则不能显示
// 具体可以参考 Go 语言的源码
func IsPrint(r rune) bool

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

	fmt.Println(strconv.IsPrint(0))    // false

}

strconv
strconv.Quote(s string)string -> 返回字符串在go语法下的双引号字面值表示，控制字符和不可打印字符会进行转义(\t,\n等)
strconv.QuoteToASCII(s string)string -> 返回字符串在go语法下的双引号字面值表示，除了上面的和非ASCII字符会进行转义
strconv.QuoteRune(r rune)string -> 返回字符r在go语法下的单引号字面值表示，控制字符，不可打印字符会进行转义(\n,\t,\xFF等)
strconv.QuoteRuneToASCII(r rune)string -> 返回字符r在go语法下的单引号字面值表示，除了上面的，非ASCII字符也会进行转义
strconv.Unquote(s string)(t string,err error) -> 函数假设s是一个半引号、双引号、反引号包围的go语法字符串，解析它并返回它表示的值。(如果是单引号括起来的，函数会认为s是go字符字面值，返回一个单字符的字符串)
strconv.ParseBool(str string)(value bool,err error),返回字符串表示的bool值。它接受1、0、t，f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误
strconv.ParseInt(s string, base int, bitSize int)(i int64,err error) -> 返回字符串表示的整数值，接受正负号。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=ErrorRange
strconv.ParseUint(s string,base int,bitSize)(n uint64, err error) -> 类似ParseInt但不接受正负号，用于无符号整型
strconv.Float(a string,bitSize int)(f float64,err error) -> 解析一个表示浮点数的字符串并返回其值。如果s合乎语法规则，函数会返回最为接近s表示值的一个浮点数(使用IEEE754规范舍入)。bitSize指定了期望的接收类型，32是float32,64是float64,返回值是NumErr
strconv.FormatBool(b bool)string -> 根据b的值返回”true”或”false”
strconv.FormatInt(i int64,base int)string -> 返回的i的base进制的字符串表示，base必须在2-36之间，结果中会使用小写字母a到z表示大于10的数字
strconv.FormatUint(i uint64, base int)string -> 是FormatInt的无符号整数版本
strconv.FormFloat(f float64,fmt byte,prec,bitSize int)string -> 函数将浮点数表示为字符串并返回。bitSize表示的来源类型(32:float32,64:float64)，会据此进行舍入。
strconv.Atoa(s string)(i int,err error) -> Atoi是ParseInt(s,10,0)的简写
strconv.Itoa(i int)string -> Format(i,10)的简写
---------------------
eg：

package main

import "fmt"
import "strconv"

func main() {
/*
由于将字符串转为其他数据类型可能会出错，strconv 包定义了两个 error 类型的变量：ErrRange 和 ErrSyntax。
其中，ErrRange 表示值超过了类型能表示的最大范围，比如将 "128" 转为 int8 就会返回这个错误；ErrSyntax 表示语法错误，比如将 "" 转为 int 类型会返回这个错误。
func syntaxError(fn, str string) *NumError {
return &NumError{fn, str, ErrSyntax}
}

func rangeError(fn, str string) *NumError {
return &NumError{fn, str, ErrRange}
}
*/
/* 字符串转为整数
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func Atoi(s string) (i int, err error)
*/
n, err := strconv.ParseInt("128", 10, 8)
if err != nil {
fmt.Println(err)
}
fmt.Println(strconv.ParseInt("134", 10, 64))

/*
func FormatUint(i uint64, base int) string // 无符号整型转字符串
func FormatInt(i int64, base int) string // 有符号整型转字符串
func Itoa(i int) string
*/

//还可以用 fmt.Sprintf("%d",i) 来转化，但是我们分别循环转换了10000次。Sprintf 的时间是 3.549761ms，而 Itoa 的时间是 848.208us，相差 4 倍多。

/* 字符串和布尔值之间的转换
// 接受 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False 等字符串；
// 其他形式的字符串会返回错误\
func ParseBool(str string) (value bool, err error)
// 直接返回 "true" 或 "false"
func FormatBool(b bool) string
// 将 "true" 或 "false" append 到 dst 中
// 这里用了一个 append 函数对于字符串的特殊形式：append(dst, "true"...)
func AppendBool(dst []byte, b bool)
*/

/* 字符串和浮点数之间的转换
func ParseFloat(s string, bitSize int) (f float64, err error)
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int)
*/
strconv.FormatFloat(1223.13252, 'e', 3, 32) // 结果：1.223e+03
strconv.FormatFloat(1223.13252, 'g', 3, 32) // 结果：1.22e+03
//由于浮点数有精度的问题，精度不一样，ParseFloat 和 FormatFloat 可能达不到互逆的效果。如：
s := strconv.FormatFloat(1234.5678, 'g', 6, 64)
strconv.ParseFloat(s, 64)

//如果要输出这样一句话：This is "studygolang.com" website. 该如何做？
fmt.Println(`This is "studygolang.com" website`)
fmt.Println("This is", strconv.Quote("studygolang.com"), "website")

}

秒客网

go中 -strconv包的使用

相关文章