Golang 基础库之Strconv

已于 2023-03-27 10:59:38 修改
阅读量2.4k 收藏 1
点赞数 1
分类专栏： Golang 文章标签： golang c语言 开发语言
于 2022-10-28 16:19:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44558408/article/details/127573810
版权

Strconv

参考资料：

http://c.biancheng.net/view/vip_7305.html
https://vimsky.com/examples/list/code-usage-page-1.html

标准库中文文档：

https://studygolang.com/pkgdoc

  • strconv包实现了基本数据类型和其字符串表示的相互转换。

实现了基本数据类型与其字符串表示的转换，主要有以下常用函数：

1. Atoi()

等价于ParseInt（s，10，0）;
两个返回值

  • int 类型：转换结果
  • error类型：错误信息
// Atoi is equivalent to ParseInt(s, 10, 0), converted to type int.
func Atoi(s string) (int, error)

func tAtoi() {
	var s string = "100"
	i, err := strconv.Atoi(s)
	if err != nil {
		fmt.Println("can't convert to int!,", err)
	} else {
		fmt.Printf("type:%T value:%#v\n", i, i)
	}
}

//结果
type:int value:100

//转换失败：s="10a0"
can't convert to int!, strconv.Atoi: parsing "10a0": invalid syntax

2. Itoa()

等价于FormatInt(int64(i), 10)；
只有一个结果返回值

// Itoa is equivalent to FormatInt(int64(i), 10).
func Itoa(i int) string {
	return FormatInt(int64(i), 10)
}

func tItoA() {
	var i int = 100
	s := strconv.Itoa(i)
	fmt.Printf("type:%T value:%#v\n", s, s)
}

//结果
type:string value:"100"

3. Parse系列函数

Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseInt()、ParseUint()、ParseFloat()。

3.1 ParseBool()

返回字符串表示的bool值。它接受 “1”, “t”, “T”, “true”, “TRUE”, “True”,“0”, “f”, “F”, “false”, “FALSE”, “False”；否则返回错误。

// ParseBool returns the boolean value represented by the string.
// It accepts 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False.
// Any other value returns an error.
func ParseBool(str string) (bool, error) {
	switch str {
	case "1", "t", "T", "true", "TRUE", "True":
		return true, nil
	case "0", "f", "F", "false", "FALSE", "False":
		return false, nil
	}
	return false, syntaxError("ParseBool", str)
}
3.2 ParseInt()
  • 返回字符串表示的整数值，接受正负号。
  • base指定进制（2到36），如果base为0，则会从字符串前置判断，”ob“表示2进制，”0”或”0o“是8进制，否则是10进制，”0x”是16进制，否则为十进制；
  • bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64，如果bitSize低于0或高于64，返回错误；
  • 返回的err是 *NumErr 类型的，如果语法有误，err.Error = ErrSyntax；如果结果超出类型范围err.Error = ErrRange。
func ParseInt(s string, base int, bitSize int) (i int64, err error)

func tParseInt() {
	str := "-11"
	i, err := strconv.ParseInt(str, 10, 0)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("type:%T value:%#v\n", i, i)
	}
	i2, err2 := strconv.ParseInt(str, 8, 0)//str是8进制的，结果永远是10进制的结果
	if err != nil {
		fmt.Println(err2)
	} else {
		fmt.Printf("type:%T value:%#v\n", i2, i2)
	}
}

//结果
type:int64 value:-11
type:int64 value:-9
3.3 ParseUint()
  • ParseUint() 函数的功能类似于 ParseInt() 函数，但 ParseUint() 函数不接受正负号，用于无符号整型，函数签名如下：
// ParseUint is like ParseInt but for unsigned numbers.
//
// A sign prefix is not permitted.
func ParseUint(s string, base int, bitSize int) (uint64, error)
3.4 ParseFloat()
  • ParseFloat将字符串s转换为浮点数，精度由bitSize指定：32表示float32，64表示float64。
  • 当bitSize＝32时，结果的类型仍然是float64，但它可以转换为float32而不改变其值。
  • ParseFloat接受10进制和16六进制浮点数语法
  • 如果 s 合乎浮点数语法规则，函数会返回最为接近 s 表示值的一个浮点数（使用 IEEE754 规范舍入）。
  • （解析十六进制浮点值时，只有当十六进制表示形式中的位多于尾数时，才会进行四舍五入。）
  • 返回值 err 是 *NumErr 类型的，如果语法有误 err.Error=ErrSyntax，如果返回值超出表示范围，返回值 f 为 ±Inf，err.Error= ErrRange。
func ParseFloat(s string, bitSize int) (float64, error) {
	f, n, err := parseFloatPrefix(s, bitSize)
	if n != len(s) && (err == nil || err.(*NumError).Err != ErrSyntax) {
		return 0, syntaxError(fnParseFloat, s)
	}
	return f, err
}

func tParseFloat() {
	str := "3.1415926"
	fl, err := strconv.ParseFloat(str, 64)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Printf("type:%T value:%#v\n", fl, fl)
	}

	{
		str := "NaN"
		fl, err := strconv.ParseFloat(str, 64)
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Printf("type:%T value:%#v\n", fl, fl)
		}
	}

}

//结果
type:float64 value:3.1415926
type:float64 value:NaN

4. Format系列函数

  • Format 系列函数实现了将给定类型数据格式化为字符串类型的功能，其中包括 FormatBool()、FormatInt()、FormatUint()、FormatFloat()。
4.1 FormatBool()
  • 根据b的值，返回字符串类型的"true"或者"false"
// FormatBool returns "true" or "false" according to the value of b.
func FormatBool(b bool) string {
	if b {
		return "true"
	}
	return "false"
}
4.2 FormatInt()
  • FormatInt返回给定base i的字符串表示形式， 2<=base<=36。
// FormatInt returns the string representation of i in the given base,
// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
// for digit values >= 10.
func FormatInt(i int64, base int) string {
	if fastSmalls && 0 <= i && i < nSmalls && base == 10 {
		return small(int(i))
	}
	_, s := formatBits(nil, uint64(i), base, i < 0, false)
	return s
}

func tFormatInt() {
	var i int64 = 10
	s := strconv.FormatInt(i, 2)
	fmt.Printf("type:%T value:%#v\n", s, s)

	{
		s := strconv.FormatInt(i, 16)
		fmt.Printf("type:%T value:%#v\n", s, s)
	}

}

//结果
type:string value:"1010"
type:string value:"a"
4.3 FormatUint()
  • 与FormatInt()类似
// FormatUint returns the string representation of i in the given base,
// for 2 <= base <= 36. The result uses the lower-case letters 'a' to 'z'
// for digit values >= 10.
func FormatUint(i uint64, base int) string {
	if fastSmalls && i < nSmalls && base == 10 {
		return small(int(i))
	}
	_, s := formatBits(nil, i, base, false, false)
	return s
}
4.4 FormatFloat()
  • FormatFloat根据格式fmt和精度prec将浮点数f转换为字符串。
    • fmt值如下：
      • ‘b’ (-ddddp±ddd, a binary exponent) 二进制指数
      • ‘e’ (-d.dddde±dd, a decimal exponent) 十进制指数
      • ‘E’ (-d.ddddE±dd, a decimal exponent) 十进制指数
      • ‘f’ (-ddd.dddd, no exponent) 无指数
      • ‘g’ (‘e’ for large exponents, ‘f’ otherwise) 指数很大时，同’e’，否则同’f’
      • ‘G’ (‘E’ for large exponents, ‘f’ otherwise) 指数很大时，同’E’，否则同’f’
      • ‘x’ (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent) 十六进制小数和二进制指数
      • ‘X’ (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent) 十六进制小数和二进制指数
    • prec：精度prec，由’e’、‘E’、‘f’、‘g’、‘G’、'x’和’X’格式打印的位数（不包括指数）控制。
      • 对于“e”、“E”、“f”、“x”和“X”，它是小数点后的位数
      • 对于“g”和“G”，是最大有效位数（去掉尾随的零）
      • 如果 prec 为 -1，使用必要的最小位数，这样ParseFloat将精确返回f
  • bitSize 表示参数 f 的来源类型（32 表示 float32、64 表示 float64），会据此进行舍入
func FormatFloat(f float64, fmt byte, prec, bitSize int) string {
	return string(genericFtoa(make([]byte, 0, max(prec+4, 24)), f, fmt, prec, bitSize))
}

func tFormatFloat() {
	var num float64 = 123.1415
	strb := strconv.FormatFloat(num, 'b', -1, 64)
	fmt.Printf("strb type:%T,value:%v\n ", strb, strb)

	stre := strconv.FormatFloat(num, 'e', 7, 64)
	fmt.Printf("stre type:%T,value:%v\n ", stre, stre)

	strE := strconv.FormatFloat(num, 'E', 6, 64)
	fmt.Printf("strE type:%T,value:%v\n ", strE, strE)

	strf := strconv.FormatFloat(num, 'f', -1, 64)
	fmt.Printf("strf type:%T,value:%v\n ", strf, strf)

	strg := strconv.FormatFloat(num, 'g', 7, 64)
	fmt.Printf("strg type:%T,value:%v\n ", strg, strg)

	strG := strconv.FormatFloat(num, 'G', 6, 64)
	fmt.Printf("strG type:%T,value:%v\n ", strG, strG)

	strx := strconv.FormatFloat(num, 'x', 7, 64)
	fmt.Printf("strx type:%T,value:%v\n ", strx, strx)

	strX := strconv.FormatFloat(num, 'X', 6, 64)
	fmt.Printf("strX type:%T,value:%v\n ", strX, strX)

}

//结果
strb type:string,value:8665312711153811p-46
 stre type:string,value:1.2314150e+02
 strE type:string,value:1.231415E+02
 strf type:string,value:123.1415
 strg type:string,value:123.1415
 strG type:string,value:123.141
 strx type:string,value:0x1.ec90e56p+06
 strX type:string,value:0X1.EC90E5P+06

5. Append系列函数

  • Append 系列函数和 Format 系列函数的使用方法类似，只不过是将转换后的结果追加到一个切片中。
  • 包含了AppendBool()、AppendInt()、AppendUint()、AppendFloat()等函数。

下面举了一个AppendInt()的例子

// AppendInt appends the string form of the integer i,
// as generated by FormatInt, to dst and returns the extended buffer.
func AppendInt(dst []byte, i int64, base int) []byte

func tAppendInt() {
	// 声明一个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

6. IsPrint

  • 返回一个字符是否是可打印的，和unicode.IsPrint一样，r必须是：字母（广义）、数字、标点、符号、ASCII空格。
func IsPrint(r rune) bool

func main() {
	fmt.Println(strconv.IsPrint('a'))
	fmt.Println(strconv.IsPrint('\n'))
    fmt.Println(strconv.IsPrint('♥'))
}

//结果
true
false
true

7. IsGraphic

  • 用于检查符文是否被 Unicode 定义为 Graphic。此类字符包括字母、标记、数字、标点符号、符号和空格，来自类别 L、M、N、 P、S 和 Z。
// IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such
// characters include letters, marks, numbers, punctuation, symbols, and
// spaces, from categories L, M, N, P, S, and Zs.
func IsGraphic(r rune) bool

func main() {
	fmt.Println(strconv.IsGraphic('a'))
	fmt.Println(strconv.IsGraphic('\n'))
	fmt.Println(strconv.IsGraphic('♥'))
}

//结果
true
false
true

8. Quote系列函数

  • Quote系列函数
8.1 Quote()
  • 返回字符串s在go语法下的双引号字面值表示，控制字符、不可打印字符会进行转义。（如\t，\n，\xFF，\u0100）
// Quote returns a double-quoted Go string literal representing s. The
// returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
// control characters and non-printable characters as defined by
// IsPrint.
func Quote(s string) string {
	return quoteWith(s, '"', false, false)
}

func main() {
	fmt.Println(strconv.Quote("Hello World!"))
	fmt.Println(strconv.Quote(`" Hello
	 World! "`))
}

//结果
"Hellow World!"
"\" Hello\n\t World! \""
8.2 QuoteRune()
  • 返回字符r在go语法下的单引号字面值表示，控制字符、不可打印字符会进行转义。（如\t，\n，\xFF，\u0100）
  • 如果r的值不再unicode码值范围内，则返回U+FFFD
  • 参数r的类型为rune，rune是类型int32的别名，用来代表字符值。
    • 可以使用rune统计字符串长度len([]rune(”Golang编程!“)) //输出9 而len(“Golang编程!”)输出的是13，一个中文字符占3个字节。
// QuoteRune returns a single-quoted Go character literal representing the
// rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100)
// for control characters and non-printable characters as defined by IsPrint.
// If r is not a valid Unicode code point, it is interpreted as the Unicode
// replacement character U+FFFD.
func QuoteRune(r rune) string {
	return quoteRuneWith(r, '\'', false, false)
}

func main() {
	if strconv.IsPrint(rune(65)) {
		fmt.Println(strconv.QuoteRune(rune(65))) //A
	}
	if strconv.IsPrint(rune(10)) {
		fmt.Println(strconv.QuoteRune(rune(10))) //换行
	}
	fmt.Println(strconv.QuoteRune('♥'))
	fmt.Println(strconv.QuoteRune('s'))
}
//结果
'A'
'♥'
's'

//单独执行fmt.Println(strconv.QuoteRune(rune(10)))结果
'\n'
8.3 QuoteRuneToASCII()
  • 返回字符r在go语法下的单引号字面值表示，控制字符、不可打印字符、非ASCII字符会进行转义。
  • 如果r的值不再unicode码值范围内，则返回U+FFFD
func QuoteRuneToASCII(r rune) string {
	return quoteRuneWith(r, '\'', true, false)
}

func main() {
	if strconv.IsPrint(rune(65)) {
		fmt.Println(strconv.QuoteRuneToASCII(rune(65))) //A
	}
	if strconv.IsPrint(rune(10)) {
		fmt.Println(strconv.QuoteRuneToASCII(rune(10))) //换行
	}
	fmt.Println(strconv.QuoteRuneToASCII('♥'))
	fmt.Println(strconv.QuoteRuneToASCII('s'))
	fmt.Println(strconv.QuoteRuneToASCII(rune(65555555)))
}

//结果
'A'
'\u2665'
's'
'\ufffd'

//持续更新…

家了叭叭
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Golang标准库学习——strconv
Lazyboy_的博客
05-20 1723
package strconv import "strconv" strconv包实现了基本数据类型和其字符串表示的相互转换。 之前写惯了C++，to_string()之类的写惯了，现在换成golang了好几次直接顺手atoi然后报错。不习惯规不习惯，总的来说把方法放到包里这个想法还是很ok的。 strconv.Itoa()和strconv.Atoi() Itoa实现了in...
Go-“无用“的优化-strconv.Atoi()
写写记记
10-18 575
Go 优化
Golang 中的 strconv 包详解
路多辛的所思所想
06-28 929
strconv 是 Golang 中一个非常常用的包，主要用于字符串和基本数据类型之间的相互转换。本文将详细介绍 strconv 包的常用函数及用法。
golang标准库学习——一文搞懂golang常用标准库
最新发布
一弓虽的博客
05-28 1125
一文讲述golang所有常用的标准库
strconv---用来基本类型之间的转换
koooooooo5的博客
04-09 972
strconv---用来基本类型之间的转换 字符串转int：Atoi(s string)(i int,err error) int转字符串: Itoa(i int)string string转换为对应TP类型：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。因为string转其它类型可能会失败，所以这些函数都有第二个返回值表示是否转换成功 strconv.ParseBool(str string)(value bool,err error) //接受1、0
一文了解 Go 标准库 strconv：string 与其他基本数据类型的转换
cmy_top的博客
12-01 470
本文将以 string 类型为中心，通过 strconv 标准库，介绍其与其他基本数据类型相互转换的函数。
golang标准库api文档
12-08
1. **基础库** - `fmt`: 提供格式化输入输出，类似于C的printf和scanf。 - `io`: 提供基本的输入输出接口，是所有I/O操作的基础。 - `bufio`: 提供缓冲的I/O操作，提高读写效率。 - `os`: 与操作系统进行交互，...
std：Golang标准库
02-18
本篇文章将深入探讨“std：Golang标准库”的相关知识点。 1. **标准库概述** Go的标准库非常丰富，包括了网络、文件系统、加密/解密、压缩、数学计算、文本处理、并发控制等多个方面的工具和接口。这些包被组织成...
leetcode:重新启动Golang的leetcode存储库
03-19
首先，让我们了解Golang（Go语言）的基础。Go是由Google开发的一种静态类型的、编译型的、垃圾回收的、并发型的、具有C风格语法的编程语言。它的设计目标是高效、简洁和可读性，尤其适合构建网络服务和系统工具。Go...
使用golang写一个redis-cli的方法示例
09-09
在本文中，我们将探讨如何使用Golang编写一个简单的...这个过程虽然涉及多个步骤，但Golang的网络库提供了方便的接口，使得实现这样一个客户端变得相对简单。通过实践，你可以更好地掌握Golang网络编程和Redis协议。
Golang包学习.zip_DEMO_HTSP_golang_golang 联合_police37w
07-13
在本压缩包中，我们聚焦于Golang编程语言的学习，特别是关于其标准库中的几个重要包的使用。这些包包括`bytes`、`regexp`、`bufio`、`unicode`、`strconv`、`io`、`fmt`、`unicode/utf8`以及`unicode/utf16`和`io/...
go语言的strconv.ParseInt(）的参数
weixin_42069809的博客
11-22 8508
输出int64类型数据，bitSize的含义是大小限制，如果s1转化的整形数据类型超过127，那么err就会显示数据超出范围，且输出的int64为127。很多人以为是指定输出的数据类型，其实strconv.ParseInt(）类型数据，一个是err信息，会显示是否超出第三个参数限制的大小。strconv.ParseInt 是将字符串转换为数字的函数。strconv.ParseInt(）的使用需要三个参数。2、转化后所需要的进制，2到32进制。1、一个string类型的字符串。有两个输出，一个是转换后的。
【搞定Go语言】第2天18：Go语言内置包之strconv
就叫一片白纸的博客
11-28 426
Go语言中strconv包实现了基本数据类型和其字符串表示的相互转换。 strconv包 strconv包实现了基本数据类型与其字符串表示的转换，主要有以下常用函数： Atoi()、Itia()、parse系列、format系列、append系列。 更多函数请查看官方文档。 string与int类型转换 这一组函数是我们平时编程中用的最多的。 Atoi() Atoi()函数用于将字符串类型的整数转换为int类型，函数签名如下。 func Atoi(s string) (i int, err error)
Golang中 strconv.Itoa()和string()的使用对比：
梦~'
01-26 1350
工作中有时会因为不严谨和疏忽(也可能是保留了之前写C的习惯)，有时会犯一些坑爹的小错误，如int转string时，居然会用强制类型转换去做，导致转换后的结果是奇怪的字符，对比示例如下： /* 1.数值类型和string类型之间的相互转换可能造成值部分丢失；其他的转换仅是类型的转换，不会造成值的改变; 2.string和数字之间转换可使用标准库strconv; 3.x是一个字符串，T是[]byte或 []rune。这种情况下可以用string(): []byte -> strin.
转投go系列-atoi和itoa和iota的区别
SIMON DOMAIN
01-29 804
Atoi和ItoA都是strconv标准库里面的方法： Atoi（ascii to integer） 字符串转化为整数 // Atoi is equivalent to ParseInt(s, 10, 0), converted to type int. func Atoi(s string) (int, error) { } ItoA (integer to ascii) 整数转换成字符串 // Itoa is equivalent to FormatInt(int64(i), 10). func It
九、Go语言库之strconv包--GO语言笔记
alvine008的专栏
04-29 3154
package mainimport "fmt" import "strconv"func main() { /* 由于将字符串转为其他数据类型可能会出错，strconv 包定义了两个 error 类型的变量：ErrRange 和 ErrSyntax。 其中，ErrRange 表示值超过了类型能表示的最大范围，比如将 "128" 转为 int8
golang strconv
weixin_33963594的博客
08-07 74
a:=strconv.FormatFloat(10.100,'f',-1,32)输出:10.1a:=strconv.FormatFloat(10.101,'f',-1,64)输出:10.101a:=strconv.FormatFloat(10.010,'f',-1,64)输出：10.01a:=strconv.FormatFloat(10.1,'f',2,6...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值