Go语言-strconv包

strconv包实现了基本数据类型与其字符串表示的转换，主要有以下常用函数： Atoi()、Itia()、parse系列、format系列、append系列。下面主要介绍了string与int类型转换、parse系列、format系列。append系列后续再做总结。

string与int类型转换

1.Atoi()函数用于将字符串类型的整数转换为int类型，函数签名如下

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

如果传入的字符串无法转化，将会报错

	major, err := strconv.Atoi(c.Query(MAJOR))
	if err != nil {
		logrus.Debugf("controller.FormList:%v", err.Error())
		c.JSON(http.StatusOK, response.NewBaseResponseWithMessage(response.ResponseCodeBadRequest, "请求参数异常"))
		return
	}

2.Itoa()函数用于将int类型的数据转化为对应的字符串

函数签名：

func Itoa(i int) string {

Parse系列函数

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

1.ParseBool()

函数返回由字符串表示的布尔值

下面为该方法的源码。从源码中可以看出，该方法只接受"1", “t”, “T”, “true”, “TRUE”, “True”,“0”, “f”, “F”, “false”, “FALSE”, “False”,否则返回错误。

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)
}

2.ParseFloat()

返回字符串表示的整数值，接受正负号。
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 = ErrRange。
源码如下：

func ParseInt(s string, base int, bitSize int) (i int64, err error) {
	const fnParseInt = "ParseInt"

	if s == "" {
		return 0, syntaxError(fnParseInt, s)
	}

	// Pick off leading sign.
	s0 := s
	neg := false
	if s[0] == '+' {
		s = s[1:]
	} else if s[0] == '-' {
		neg = true
		s = s[1:]
	}

	// Convert unsigned and check range.
	var un uint64
	un, err = ParseUint(s, base, bitSize)
	if err != nil && err.(*NumError).Err != ErrRange {
		err.(*NumError).Func = fnParseInt
		err.(*NumError).Num = s0
		return 0, err
	}

	if bitSize == 0 {
		bitSize = int(IntSize)
	}

	cutoff := uint64(1 << uint(bitSize-1))
	if !neg && un >= cutoff {
		return int64(cutoff - 1), rangeError(fnParseInt, s0)
	}
	if neg && un > cutoff {
		return -int64(cutoff), rangeError(fnParseInt, s0)
	}
	n := int64(un)
	if neg {
		n = -n
	}
	return n, nil
}

3.ParseUnit()

源码注释： ParseUint is like ParseInt but for unsigned numbers.
ParseUnit和ParseInt相似，但是用于转化无符号数字。
源码比较长，就不贴了。只写一下方法签名：

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

4.ParseFloat()

ParseFloat将字符串s转换为浮点数，精度由bitSize指定：32表示float32，64表示float64。当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”和“-Inf”识别为各自的特殊浮点值。匹配时忽略大小写

func ParseFloat(s string, bitSize int) (float64, error) {
	if !underscoreOK(s) {
		return 0, syntaxError(fnParseFloat, s)
	}
	if bitSize == 32 {
		f, err := atof32(s)
		return float64(f), err
	}
	return atof64(s)
}

Format系列

1.FormatBool()

根据b的值返回"true"或者"false"的字符串

源码

func FormatBool(b bool) string {
	if b {
		return "true"
	}
	return "false"
}

2.FormatInt()

方法签名中base表示进制,base 必须在2到36之间，结果中会使用小写字母’a’到’z’表示大于10的数字。
返回i数字指定进制的字符串。

源码如下

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
}

3.FormatUint()

该方法的使用跟FormatInt是一样的，唯一不同的地方就是刚方法接收的参数i为无符号的。

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.FormatFloat()

FormatFloat根据格式fmt和prec将浮点数f转换为字符串并返回。

bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。

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’，它表示小数点后的数字个数；对’g’、’G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。

方法签名

func FormatFloat(f float64, fmt byte, prec, bitSize int) string {
	return string(genericFtoa(make([]byte, 0, max(prec+4, 24)), f, fmt, prec, bitSize))
}