go语言的内置包之strconv

发表于 | 分类于 | 浏览 次

go语言内置包之strconv

简介

go语言的内置包sreconv实现了基本数据类型和字符串之间的相互转换。

常用函数

Atoi()

将字符串类型的整数转换为int类型。函数原型为：

1
func Atoi(s string) (int, error) {}

如果传入的参数无法转换为int类型。就会返回错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
    "fmt"
    "strconv"
)

func main() {
    s1 := "5201314"
    i1, err := strconv.Atoi(s1)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("类型：%T\t值：%#v\n",i1, i1)
    }
    s2 := "江子牙"
    i2, err := strconv.Atoi(s2)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("类型：%T\t值：%#v\n",i2, i2)
    }
}

执行结果：

1
2
类型：int	值：5201314
strconv.Atoi: parsing "江子牙": invalid syntax

Itoa()

将int类型数据转化为对应的字符串表示。函数原型为：

1
func Itoa(i int) string {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import (
    "fmt"
    "strconv"
)

func main() {
    i1 := 5201315
    s1 := strconv.Itoa(i1)
    
    // 类型：string	值："5201315"
    fmt.Printf("类型：%T\t值：%#v", s1, s1)
}

parse系列

parse系列函数用于转换字符串为给定类型的值。

ParseBool()

1
func ParseBool(str string) (bool, error) {}

返回字符串表示的bool值，但是只接收1、0、false、true、False、True、t、T、F、f、TRUE、FALSE，否则返回错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import (
    "fmt"
    "strconv"
)

func testBool(s string) {
    b1, err := strconv.ParseBool(s)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("类型：%T\t值：%#v\n", b1, b1)
    }
}

func main() {
    s1 := "1"
    testBool(s1)
    s2 := "t"
    testBool(s2)
    s3 := "F"
    testBool(s3)
    s4 := "-2"
    testBool(s4)

}

执行结果：

1
2
3
4
类型：bool	值：true
类型：bool	值：true
类型：bool	值：false
strconv.ParseBool: parsing "-2": invalid syntax

ParseFloat()

解析一个浮点数表示的字符串。函数原型为：

1
func ParseFloat(s string, bitSize int) (float64, error) {}

bitsize表示期望的接受类型。32代表float32，64代表float64。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import (
    "fmt"
    "strconv"
)

func testFloat(s string) {
    b1, err := strconv.ParseFloat(s, 64)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("类型：%T\t值：%#v\n", b1, b1)
    }
}

func main() {
    s1 := "1"
    testFloat(s1)
    s2 := "3.14159"
    testFloat(s2)
    s3 := "2.22222"
    testFloat(s3)
    s4 := "呵呵"
    testFloat(s4)

}

执行结果：

1
2
3
4
类型：float64	值：1
类型：float64	值：3.14159
类型：float64	值：2.22222
strconv.ParseFloat: parsing "呵呵": invalid syntax

ParseInt()

解析字符串表示的整数值，接收正负号，函数原型为：

1
func ParseInt(s string, base int, bitSize int) (i int64, err error) {}

base表示指定进制，如果base为0，则会从字符串前缀判断。ox是十六进制，o是八进制。否则是十进制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main

import (
    "fmt"
    "strconv"
)

func testInt(s string, base int, bitSize int) {
    b1, err := strconv.ParseInt(s, base, bitSize)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("类型：%T\t值：%#v\n", b1, b1)
    }
}

func main() {
    s1 := "1"
    testInt(s1, 0, 64)
    // 十六进制
    s2 := "0x10"
    testInt(s2, 0, 64)
    s4 := "-19"
    testInt(s4, 0, 64)
    s5 := "呵呵"
    testInt(s5, 0, 64)
    // 八进制
    s6 := "011"
    testInt(s6, 0, 64)
    // 二进制
    s7 := "1111"
    testInt(s7, 2, 64)
}

执行结果：

1
2
3
4
5
6
类型：int64	值：1
类型：int64	值：16
类型：int64	值：-19
strconv.ParseInt: parsing "呵呵": invalid syntax
类型：int64	值：9
类型：int64	值：15

ParseUnit()

与ParseInt类似，但是不接受正负号，用于无符号整型。函数原型为：

1
func ParseUint(s string, base int, bitSize int) (n uint64, err error) {}

format系列

与Parse系列函数相反。将给定的数据类型的值转为字符串。

FormatBool()

将布尔值格式化为对应的字符串，函数原型为：

1
func FormatBool(b bool) string {}

返回值为true或者false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import (
    "fmt"
    "strconv"
)

func testBool(b bool) {

    s := strconv.FormatBool(b)
    fmt.Println(s)
}

func main() {
    b1 := true
    var b2 bool
    testBool(b1)
    testBool(b2)
}

执行结果：

1
2
true
false

FormatInt()

将数字格式化为对应的字符串，支持指定进制，函数原型为：

1
func FormatInt(i int64, base int) string {}

base 必须在2到36之间，结果中会使用小写字母’a’到’z’表示大于10的数字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import (
    "fmt"
    "strconv"
)

func testInt(i int64, base int) {

    s := strconv.FormatInt(i, base)
    fmt.Printf("类型：%T\t值：%#v\n", s, s)
}

func main() {
    var i1 int64 = 10
    var i2 int64 = 16
    testInt(i1, 2)
    testInt(i2, 16)
}

执行结果：

1
2
类型：string	值："1010"
类型：string	值："10"

FormatUnit()

是FormatInt的无符号整数版本，函数原型为：

1
func FormatUint(i uint64, base int) string {}

FormatFloat()

将浮点型的数字转换为对应的字符串，函数原型为：

1
func FormatFloat(f float64, fmt byte, prec, bitSize int) string {}

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。

1
2
3
4
5
6
7
8
9
10
11
12
package main

import (
    "fmt"
    "strconv"
)

func main() {
    s1 := strconv.FormatFloat(3.1415, 'E', -1, 64)
    // 3.1415E+00
    fmt.Println(s1)
}
/