go：内置库包strconv

import_random
164 阅读7分钟

参考网址

blog.csdn.net/u013252047/…

blog.csdn.net/weixin_4455…

总结

大家都知道，在任何一门编程语言中，字符串类型是经常会用到的数据类型。
同时，还存在其他的数据类型，比如int,int32,int64,float32,float64等。

所以，就会经常遇到不同类型之间转换的情况 convert(转换)

strconv包实现了：
     **基本数据类型**和其**字符串**表示的相互转换。
     
     
Parse()系列函数，是把string --> 其他数据类型
Format()系列函数，是把其他类型 --> string

0/前言

在go开发中，经常会遇到字符串类型和其他类型进行转换的场景。
strconv这个go的内置标准库包可以满足这个需求。
顾名思义，从strconv字面上来看，也知道strconv是字符串类型和其他数据类型之间进行转换的工具。

1/string --> int

字符串-->整数，有两种方法，
第一种：
    可以使用func Atoi(s string) (i int, err error)，Atoi代表Ascii to Integer。
第二种：
    还可以使用func ParseInt(s string, base int, bitSize int) (i int64, err error)，
    base代表进制，值为2~36，如果为0，则会根据字符串自动判断，前置为"0x"的是16进制，前置为"0"的是8进制，其余的为10进制，
    bitSize是返回的整数类型，0、8、16、32分别代表int、int8、int16、int32。

<1>strconv.Atoi()函数

该函数，只有1个入参

func main() {
    a,_ := strconv.Atoi("123456")  // 只有一个入参，ascii --> int

}
// 输出结果
a values 123456

<2>strconv.ParseInt()函数

该函数，有3个入参

func main() {
    // 把‘123456’转换为10进制的int32类型的整数
    b,_:= strconv.ParseInt("123456", 10, 32)
    fmt.Printf("b values %v\n",b)

    // 把‘123456’转换为10进制的int16类型的整数
    c,_:= strconv.ParseInt("123456", 10, 16)
    fmt.Printf("c values %v\n",c)

    // 把‘111’转换为2进制的int32类型的整
    d,_:=strconv.ParseInt("111", 2, 32)
    fmt.Printf("d values %v\n",d)
}
// 输出结果
b values 123456
c values 32767
d values 7

2/int --> string

使用func Itoa(i int) string方法，将int类型的转string类型。

func main() {
	var i int = 12345
	s:=strconv.Itoa(i)
	fmt.Printf("s values %v,type is %T",s,s)
}

以上会输出
s values 12345,type is string

3/string --> bool

函数： strconv.ParseBool()

func main(){
fmt.Println(strconv.ParseBool("t"))
fmt.Println(strconv.ParseBool("TRUE"))
fmt.Println(strconv.ParseBool("true"))
fmt.Println(strconv.ParseBool("True"))
fmt.Println(strconv.ParseBool("0"))
fmt.Println(strconv.ParseBool("f"))
    }

以上会输出

true <nil>
true <nil>
true <nil>
true <nil>
false <nil>
false <nil>

4/string --> float

函数： strconv.ParseFloat()
func ParseFloat(s string, bitSize int) (f float64, err error)

mian(){
	f,err:=strconv.ParseFloat("20.58",64)
	if err!=nil {
		panic(err)
	}
	fmt.Printf("%v,%T",f,f)
}
// 输出
20.58,float64

5/float --> string

func FormatFloat(f float64, fmt byte, prec, bitSize int) string
其中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。

    mian(){
    	str:=strconv.FormatFloat(23.5670,'f',-1,64)
    	str2:=strconv.FormatFloat(23.5670,'f',5,64)
    	fmt.Println(str)
    	fmt.Println(str2)
    }

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)

    1

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()。
即：最终的结果都是：转换为string

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
avatar
文章
阅读
粉丝