Go——strconv包详解-CSDN博客

本文链接：https://blog.csdn.net/cold___play/article/details/130673193

本文详细介绍了Go语言中的strconv包，包括它提供的各种函数，如Atoi、Itoa、FormatFloat、ParseBool等，用于在bool、int、float和字符串类型之间进行转换。此外，还涵盖了Append系列函数，用于在字节切片中追加转换后的值，以及Quote和Unquote函数用于字符串的引号处理。文章通过示例代码展示了这些函数的使用方法和注意事项。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

strconv包

函数列表：

func AppendBool(dst []byte, b bool) []byte](AppendBool.md) 
func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte](AppendFloat.md) 
func AppendInt(dst []byte, i int64, base int) []byte](AppendInt.md) 
func AppendQuote(dst []byte, s string) []byte](AppendQuote.md) 
func AppendQuoteRune(dst []byte, r rune) []byte](AppendQuoteRune.md) 
func AppendQuoteRuneToASCII(dst []byte, r rune) []byte](AppendQuoteRuneToASCII.md) 
func AppendQuoteToASCII(dst []byte, s string) []byte](AppendQuoteToASCII.md) 
func AppendUint(dst []byte, i uint64, base int) []byte](AppendUint.md) 
func Atoi(s string) (i int, err error)](Atoi.md) 
func CanBackquote(s string) bool](CanBackquote.md) 
func FormatBool(b bool) string](FormatBool.md) 
func FormatFloat(f float64, fmt byte, prec, bitSize int) string](FormatFloat.md) 
func FormatInt(i int64, base int) string](FormatInt.md) 
func FormatUint(i uint64, base int) string](FormatUint.md) 
func IsPrint(r rune) bool](IsPrint.md) 
func Itoa(i int) string](Itoa.md) 
func ParseBool(str string) (value bool, err error)](ParseBool.md) 
func ParseFloat(s string, bitSize int) (f float64, err error)](ParseFloat.md) 
func ParseInt(s string, base int, bitSize int) (i int64, err error)](ParseInt.md) 
func ParseUint(s string, base int, bitSize int) (n uint64, err error)](ParseUint.md) 
func Quote(s string) string](Quote.md) 
func QuoteRune(r rune) string](QuoteRune.md) 
func QuoteRuneToASCII(r rune) string](QuoteRuneToASCII.md) 
func QuoteToASCII(s string) string](QuoteToASCII.md) 
func Unquote(s string) (t string, err error)](Unquote.md) 
func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)](UnquoteChar.md)

1、string和int类型转换

1.1 func Atoi(s string) (i int, err error)

参数列表：s 表示数字字符串，如“1234”
返回值：i 表示转换后的数值
功能说明：Atoi是函数ParseInt(s, 10, 0)的简写。把字符串格式的数字如“12345”转化为数字12345

1.2 func Itoa(i int) string

参数列表：i 表示需要被转换为字符串的int值
返回值：返回string 表示转换后的字符串。
功能说明：将数值按照10进制转换为字符串,是等同于FormatInt(i, 10)的简写。

func main() {
	fmt.Println(strconv.Atoi("12345")) //12345 <nil>
	fmt.Println(strconv.Atoi("abc"))   //0 strconv.Atoi: parsing "abc": invalid syntax

	fmt.Println(strconv.Itoa(11)) // 11
}

2、Format系列函数

2.1 func FormatBool(b bool) string

参数列表
- b 需要被转换的bool值
返回值：返回string 表示转换后的字符串
功能说明：将true或false转换为字符串

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

参数列表
- f 需要被转换的float64值
- fmt 转换格式 ‘b’ ‘e’ ‘E’ ‘f’ ‘g’或’G’
- prec 浮点数精度
- bitSize 32或64，32对应float32，64对应float64
返回值: 返回string 表示转换后的字符串
功能说明：
- 将浮点数转换为字符串
- 浮点数格式有’b’ (-ddddp±ddd, 二进制指数), ‘e’ (-d.dddde±dd, 十进制指数), ‘E’ (-d.ddddE±dd, 十进制指数), ‘f’ (-ddd.dddd, 无指数), ‘g’ (大指数时相当于’e’, 其他情况时相当于’f’), ‘G’ (大指数时相当于’E’, 其他情况相当于’f’).
- 精度用于控制当格式为’e’ ‘E’ ‘f’ ‘g’ ‘G’时除指数外的数字的个数；对于’e’ ‘E’ ‘f’指小数点后位数；对于’g’ 'G’则表示总共的位数；如果使用-1，表示不改变数值的最小位数

2.3 func FormatInt(i int64, base int) string

参数列表
- i 表示需要被转换为字符串的int64值
- base 表示进制数 2 <= base <= 36
返回值：返回string 表示转换后的字符串，当进制大于10时，大于10的值将使用小写a-z表示。
功能说明：将数值按照进制格式转换为字符串

2.4 func FormatUint(i uint64, base int) string

参数列表
- i 表示需要被转换为字符串的int64值
- base 表示进制数 2 <= base <= 36
返回值：返回string 表示转换后的字符串，当进制大于10时，大于10的值将使用小写a-z表示。
功能说明：将数值按照进制格式转换为字符串

func main() {
	b := strconv.FormatBool(true)
	fmt.Println(b) //true
	b = strconv.FormatBool(false)
	fmt.Println(b) //false

	fmt.Println(strconv.FormatFloat(10.1, 'b', 5, 64))        //5685794529555251p-49
	fmt.Println(strconv.FormatFloat(10.1, 'e', 5, 64))        //1.01000e+01
	fmt.Println(strconv.FormatFloat(10.1, 'E', 5, 64))        //1.01000E+01
	fmt.Println(strconv.FormatFloat(10.1, 'f', 5, 64))        //10.10000
	fmt.Println(strconv.FormatFloat(10.1, 'g', 5, 64))        //10.1
	fmt.Println(strconv.FormatFloat(100000000.1, 'g', 5, 64)) //1e+08
	fmt.Println(strconv.FormatFloat(10.1, 'G', 5, 64))        //10.1
	fmt.Println(strconv.FormatFloat(100000000.1, 'G', 5, 64)) //1E+08
	fmt.Println(strconv.FormatFloat(10.1, 'e', -1, 64))       //1.01e+01
	fmt.Println(strconv.FormatFloat(10.00001, 'e', -1, 64))   //1.000001e+01

	fmt.Println(strconv.FormatInt(8, 2))                    //1000
	fmt.Println(strconv.FormatInt(9223372036854775807, 2))  //111111111111111111111111111111111111111111111111111111111111111
	fmt.Println(strconv.FormatInt(9223372036854775807, 10)) //9223372036854775807

	fmt.Println(strconv.FormatUint(18446744073709551615, 2))  //1111111111111111111111111111111111111111111111111111111111111111
	fmt.Println(strconv.FormatUint(18446744073709551615, 10)) //18446744073709551615
}

3、Parse系列函数

3.1 func ParseBool(str string) (value bool, err error)

参数列表
- str 可以表示bool值的字符串
返回值：
- value 通过str转换的bool值
- err 当str无法转换为bool返回错误，否则为nil
功能说明：尝试将表示bool值的字符串转换为bool值。str可以是1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False，其他的字符将返回错误。

3.2 func ParseFloat(s string, bitSize int) (f float64, err error)

参数列表
- str 可以表示float64值的字符串
- bitSize 精度按64位或32位转换为float64值
返回值：
- f 通过str转换的float64值.如果解析出错，返回0；数值超范围返回±Inf。
- err 当str无法转换为float64值返回错误，否则为nil
功能说明：
- 尝试按照bitSize指定的精度将表示float64值的字符串转换为float64值。当bitSize指定32位时，返回值仍然是float64值而非float32值,但却可以在不改变数值的情况下将float64转换为float32。
- 如果s是一个float格式或接近float格式的字符串，ParseFloat将返回按照IEEE 754规范舍入的float64值。
- 返回的err是*NumError格式，并且err.Num = s
- 如果s格式不是float格式，返回语法错误 err.Err = ErrSyntax。
- 如果s格式正确但转换成浮点数值后比bitSize指定的精度的最大浮点数大1/2 ULP（unit in the last place），返回值 f = ±Inf, err.Err = ErrRange。

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

参数列表
- str 可以表示int64值的字符串
- base 进制 (2 to 36)
- bitSize 精度 0、8、16、32、64对应int、int8、int16、int32、int64
返回值：
- i 通过str转换的int64值.
- err 当str无法转换为init64值返回错误，否则为nil.
功能说明：
- 尝试按照base指定的进制(2-36)将表示int64值的字符串转换为int64值。如果base为0,则参考s的格式自动确定进制，如："0x"是16进制，"O"是8进制，其余是10进制。
- 返回err是*NumError格式，并且err.Num = s。如果s格式错误，则err.Err = ErrSyntax，并且i将返回0.如果转换的数值超过bitSize指定的带符号数值（signed integer），i将返回符合该bitSize的最大值符号数值。

3.4 func ParseUint(s string, base int, bitSize int) (n uint64, err error)

参数列表
- str 可以表示int64值的字符串
- base 进制 (2 to 36)
- bitSize 精度 0、8、16、32、64对应uint、uint8、uint16、uint32、uint64
返回值：
- i 通过str转换的uint64值.
- err 当str无法转换为uinit64值返回错误，否则为nil.
功能说明：ParseUint is like ParseInt but for unsigned numbers.

func main() {
	fmt.Println(strconv.ParseBool("1")) //true <nil>
	fmt.Println(strconv.ParseBool("0")) //false <nil>
	fmt.Println(strconv.ParseBool("a")) //false strconv.ParseBool: parsing "a": invalid syntax

	fmt.Println(strconv.ParseFloat("1.0231e2", 64)) //102.31 <nil>
	fmt.Println(strconv.ParseFloat("222.3345", 32)) //222.33450317382812 <nil>

	fmt.Println(strconv.ParseInt("9223372036854775807", 10, 64)) //9223372036854775807 <nil>
	fmt.Println(strconv.ParseInt("9223372036854775808", 10, 64)) //9223372036854775807 strconv.ParseInt: parsing "9223372036854775808": value out of range
	fmt.Println(strconv.ParseInt("0xa", 0, 64))                  //10 <nil>

	fmt.Println(strconv.ParseUint("18446744073709551615", 10, 64)) //18446744073709551615 <nil>
	fmt.Println(strconv.ParseUint("18446744073709551616", 10, 64)) //18446744073709551615 strconv.ParseUint: parsing "18446744073709551616": value out of range
	fmt.Println(strconv.ParseUint("0xa", 0, 64))                   //10 <nil>
}

4、Append系列函数

4.1 func AppendBool(dst []byte, b bool) []byte

参数列表
- dst 表示原列表
- b 表示需要添加的bool值，true或者false
返回值：[]byte 返回原列表追加bool后新生成的列表
功能说明：将布尔值 b 转换为字符串 “true” 或 “false” 然后将结果追加到 dst 的尾部，返回追加后的 []byte

4.2 func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte

参数列表
- dst 原列表
- f 需要append到列表的浮点数
- fmt 转换格式 ‘b’ ‘e’ ‘E’ ‘f’ ‘g’或’G’
- prec 浮点数精度
- bitSize 32或64，32对应float32，64对应float64
返回值:[]byte 返回列表
功能说明：
- 将浮点数f转换为字符串值，并将转换结果追加到dst的尾部，返回追加后的[]byte。
- 浮点数格式有’b’ (-ddddp±ddd, 二进制指数), ‘e’ (-d.dddde±dd, 十进制指数), ‘E’ (-d.ddddE±dd, 十进制指数), ‘f’ (-ddd.dddd, 无指数), ‘g’ (大指数时相当于’e’, 其他情况时相当于’f’), ‘G’ (大指数时相当于’E’, 其他情况相当于’f’).
- 精度用于控制当格式为’e’ ‘E’ ‘f’ ‘g’ ‘G’时除指数外的数字的个数；对于’e’ ‘E’ ‘f’指小数点后位数；对于’g’ 'G’则表示总共的位数；如果使用-1，表示不改变数值的最小位数

4.3 func AppendInt(dst []byte, i int64, base int) []byte

参数列表
- dst 表示原列表
- i 表示需要添加的int64值
- base 表示进制数 2 <= base <= 36
返回值：返回[]byte 表示原列表添加数值后新生成的列表
功能说明：类似AppendFloat，只能追加int类型，base表示int表示的进制数，返回追加后的 []byte。当进制大于10时，大于10的值将使用小写a-z表示。

4.4 func AppendQuote(dst []byte, s string) []byte

参数列表
- dst 原列表
- s 需要append到列表的字符串
返回值:[]byte 返回列表
功能说明：将字符串s转换为双引号引起来的字符串，并将结果追加到dst的尾部，返回追加后的[]byte。其中的特殊字符将被转换为转义字符

4.5 func AppendQuoteRune(dst []byte, r rune) []byte

参数列表
- dst 原列表
- r 需要append到列表的字符
返回值:[]byte 返回列表
功能说明：将符文s转换为单引号引起来的字符串，并将结果追加到dst的尾部，返回追加后的[]byte。其中的特殊字符将被转换为转义字符

4.6 func AppendQuoteRuneToASCII(dst []byte, r rune) []byte

参数列表
- dst 原列表
- r 需要append到列表的字符
返回值:[]byte 返回列表
功能说明：将符文s转换为单引号引起来的字符串，非ASCII字符将转换为ASCII，并将结果追加到dst的尾部，返回追加后的[]byte。其中的特殊字符将被转换为转义字符

4.7 func AppendUint(dst []byte, i uint64, base int) []byte

参数列表
- dst 原列表
- i 需要追加到列表的unit64值
- base unit64的进制
返回值:[]byte 返回列表
功能说明：类似AppendInt，只能追加uint类型，base表示uint表示的进制数，返回追加后的 []byte

func main() {
	newlist := strconv.AppendBool(make([]byte, 3), false)
	fmt.Println(newlist)         //[0 0 0 102 97 108 115 101]
	fmt.Println(string(newlist)) // false
	newlist = strconv.AppendBool(newlist, true)
	fmt.Println(newlist)         //[0 0 0 102 97 108 115 101 116 114 117 101]
	fmt.Println(string(newlist)) // falsetrue

	f := 100.123456789
	fmt.Println(f) //100.123456789
	c := strconv.AppendFloat(make([]byte, 0), f, 'f', 10, 32)
	fmt.Println(string(c)) //100.1234588623
	c = strconv.AppendFloat(make([]byte, 0), f, 'e', 10, 32)
	fmt.Println(string(c)) //1.0012345886e+02
	c = strconv.AppendFloat(make([]byte, 0), f, 'f', 10, 64)
	fmt.Println(string(c)) //100.1234567890
	c = strconv.AppendFloat(make([]byte, 0), f, 'e', 10, 64)
	fmt.Println(string(c)) //1.0012345679e+02

	newlist = strconv.AppendInt(make([]byte, 0), 123000, 10)
	fmt.Println(newlist)         //[49 50 51 48 48 48]
	fmt.Println(string(newlist)) //123000
	newlist = strconv.AppendInt(make([]byte, 0), 8, 2)
	fmt.Println(newlist)         //[49 48 48 48]
	fmt.Println(string(newlist)) //1000

	newlist = strconv.AppendQuote(make([]byte, 0), "")
	fmt.Println(newlist)         //[34 34]
	fmt.Println(string(newlist)) //""
	newlist = strconv.AppendQuote(make([]byte, 0), "abc")
	fmt.Println(newlist)         //[34 97 98 99 34]
	fmt.Println(string(newlist)) //"abc"
	newlist = strconv.AppendQuote(make([]byte, 0), "中文")
	fmt.Println(newlist)         //[34 228 184 173 230 150 135 34]
	fmt.Println(string(newlist)) //"中文"
	newlist = strconv.AppendQuote(make([]byte, 0), "	")
	fmt.Println(newlist)         //[34 92 116 34]
	fmt.Println(string(newlist)) //"\t"

	newlist = strconv.AppendQuoteRune(make([]byte, 0), 'a')
	fmt.Println(newlist)         //[39 97 39]
	fmt.Println(string(newlist)) //'a'
	newlist = strconv.AppendQuoteRune(make([]byte, 0), '\'')
	fmt.Println(newlist)         //[39 92 39 39]
	fmt.Println(string(newlist)) //'\''
	newlist = strconv.AppendQuoteRune(make([]byte, 0), '中')
	fmt.Println(newlist)         //[39 228 184 173 39]
	fmt.Println(string(newlist)) //'中'

	newlist = strconv.AppendQuoteRuneToASCII(make([]byte, 0), 'a')
	fmt.Println(newlist)         //[39 97 39]
	fmt.Println(string(newlist)) //'a'
	newlist = strconv.AppendQuoteRuneToASCII(make([]byte, 0), '\'')
	fmt.Println(newlist)         //[39 92 39 39]
	fmt.Println(string(newlist)) //'\''
	newlist = strconv.AppendQuoteRuneToASCII(make([]byte, 0), '中')
	fmt.Println(newlist)         //[39 92 117 52 101 50 100 39]
	fmt.Println(string(newlist)) //'\u4e2d'

	newlist = strconv.AppendUint(make([]byte, 0), 10, 2) // 1010
	fmt.Println(newlist)                                 //[49 48 49 48]
	fmt.Println(string(newlist))                         //1010
	newlist = strconv.AppendUint(make([]byte, 0), 10, 8) // 12
	fmt.Println(newlist)                                 //[49 50]
	fmt.Println(string(newlist))                         //12
}

5、其它函数

5.1 func CanBackquote(s string) bool

参数列表
- s 字符串
返回值：i 表示转换后的数值
功能说明：判断字符串 s 是否可以表示为一个单行的“反引号”字符串，字符串中不能含有控制字符（除了 \t）和“反引号”字符，否则返回 false

5.2 func IsPrint(r rune) bool

参数列表
- r 表示rune字符
返回值：返回bool true表示可以打印，false表示不可以打印。
功能说明：判断rune字符在golang中是否被定义为可打印，与unicode.IsPrint相同。可打印范围包括字符、数字、标点、符号以及ASCII中的空格。

5.3 func (e *NumError) Error() string

返回值：返回string 描述错误的字符串
功能说明：返回描述NumError类型错误的字符串

5.4 func QuoteRune(r rune) string

参数列表
- r 被引用的rune字符
返回值：返回string 将r转换为被引用的字符格式
功能说明：对s两侧添加单引号，并对r中的控制字符和不可打印的字符进行转义。

5.5 func QuoteRuneToASCII(r rune) string

参数列表
- r 被引用的rune字符
返回值：返回string 将r转换为被引用的字符格式
功能说明：对s两侧添加单引号，并对r中的非ASCII字符和不可打印的字符进行转义。

5.6 func Unquote(s string) (t string, err error)

参数列表
- s 被单引号、双引号或反引号引用的字符串
返回值：
- t 将s转换为被引用前的字符串
- err
功能说明：返回将被（单引号、双引号、反引号）引用的字符串的原字符串。（如果s是被单引号引用，则被引用的字符串必须是go中的字符，并返回该单字符的字符串。）

5.7 func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error)

参数列表
- s 转义后的字符串
- quote 字符串使用的引号符。
  如果设置为单引号，则 s 中允许出现 ’ 字符，不允许出现单独的 ’ 字符
  如果设置为双引号，则 s 中允许出现 " 字符，不允许出现单独的 " 字符
  如果设置为 0，则不允许出现 ’ 或 " 字符，可以出现单独的 ’ 或 " 字符
返回值：
- value 解码后的字符
- multibyte value是否为多字节字符
- tail 字符串 s 除去 value 后的剩余部分
- err 返回 s 中是否存在语法错误
功能说明：将 s 中的第一个字符“取消转义”并解码

func main() {
	s := strconv.CanBackquote("C:\\Windows\n")
	fmt.Println(s) // false
	s = strconv.CanBackquote("C:\\Windows\r")
	fmt.Println(s) // false
	s = strconv.CanBackquote("C:\\Windows\f")
	fmt.Println(s) // false
	s = strconv.CanBackquote("C:\\Windows\t")
	fmt.Println(s) // true
	s = strconv.CanBackquote("C:\\`Windows`")
	fmt.Println(s) // false

	fmt.Println(strconv.IsPrint(' '))  //true
	fmt.Println(strconv.IsPrint('\t')) //false
	fmt.Println(strconv.IsPrint('\n')) //false
	fmt.Println(strconv.IsPrint('\r')) //false

	err := errors.New("too large")
	er := strconv.NumError{Func: "anyfunc", Num: "1e100", Err: err}
	fmt.Println(er.Error()) //strconv.anyfunc: parsing "1e100": too large

	fmt.Println(strconv.Quote("abc	中文"))                //"abc\t中文"
	fmt.Println(strconv.Quote(strconv.Quote("abc	中文"))) //"\"abc\\t中文\""

	fmt.Println(strconv.QuoteRune('	')) //'\t'
	fmt.Println(strconv.QuoteRune(100)) //'d'

	fmt.Println(strconv.QuoteRune('中'))        //'中'
	fmt.Println(strconv.QuoteRuneToASCII('中')) //'\u4e2d'
	fmt.Println(strconv.QuoteRuneToASCII('	')) // '\t'

	test := func(s string) {
		t, err := strconv.Unquote(s)
		if err != nil {
			fmt.Printf("Unquote(%#v) error： %v\n", s, err)
		} else {
			fmt.Printf("Unquote(%#v) = %v\n", s, t)
		}
	}

	str := `cafe\u0301`
	// If the string doesn't have quotes, it can't be unquoted.
	test(str)             // Unquote("cafe\\u0301") error： invalid syntax
	test("`" + str + "`") //Unquote("`cafe\\u0301`") = cafe\u0301
	test(`"` + str + `"`) //Unquote("\"cafe\\u0301\"") = café
	test(`'\u00e9'`)      //Unquote("'\\u00e9'") = é

	sr := `\"大\\家\\好！\"`
	var c rune
	var mb bool
	var e error
	for ; len(sr) > 0; c, mb, sr, e = strconv.UnquoteChar(sr, '"') {
		fmt.Println(c, mb, sr, e)
	}
	/*
		0 false \"大\\家\\好！\" <nil>
		34 false 大\\家\\好！\" <nil>
		22823 true \\家\\好！\" <nil>
		92 false 家\\好！\" <nil>
		23478 true \\好！\" <nil>
		92 false 好！\" <nil>
		22909 true ！\" <nil>
		65281 true \" <nil>
	*/
}