字符串解析为布尔值 ParseBool

// 返回字符串表示的 bool 值，接受 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE
func ParseBool(str string) (value bool, err error)

☕️ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    flag, err := strconv.ParseBool("1")
    fmt.Println(flag, err) // true <nil>

    flag, err = strconv.ParseBool("t")
    fmt.Println(flag, err) // true <nil>

    flag, err = strconv.ParseBool("T")
    fmt.Println(flag, err) // true <nil>

    flag, err = strconv.ParseBool("true")
    fmt.Println(flag, err) // true <nil>

    flag, err = strconv.ParseBool("True")
    fmt.Println(flag, err) // true <nil>

    flag, err = strconv.ParseBool("TRUE")
    fmt.Println(flag, err) // true <nil>

    flag, err = strconv.ParseBool("TRue")
    fmt.Println(flag, err) // false strconv.ParseBool: parsing "TRue": invalid syntax

    flag, err = strconv.ParseBool("0")
    fmt.Println(flag, err) // false <nil>

    flag, err = strconv.ParseBool("f")
    fmt.Println(flag, err) // false <nil>

    flag, err = strconv.ParseBool("F")
    fmt.Println(flag, err) // false <nil>

    flag, err = strconv.ParseBool("false")
    fmt.Println(flag, err) // false <nil>

    flag, err = strconv.ParseBool("False")
    fmt.Println(flag, err) // false <nil>

    flag, err = strconv.ParseBool("FALSE")
    fmt.Println(flag, err) // false <nil>

    flag, err = strconv.ParseBool("FALse")
    fmt.Println(flag, err) // false strconv.ParseBool: parsing "FALse": invalid syntax
}

字符串解析为有符号整数 ParseInt

// 将字符串解析为整数，接受正负号
// 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)

⭐️ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    num, err := strconv.ParseInt("123", 10, 8)
    fmt.Println(num, err) // 123 <nil>

    num, err = strconv.ParseInt("12345", 10, 8)
    fmt.Println(num, err) // 127 strconv.ParseInt: parsing "12345": value out of range

    num, err = strconv.ParseInt("2147483647", 10, 0)
    fmt.Println(num, err) // 2147483647 <nil>

    num, err = strconv.ParseInt("0xFF", 16, 0)
    fmt.Println(num, err) // 0 strconv.ParseInt: parsing "0xFF": invalid syntax

    num, err = strconv.ParseInt("FF", 16, 0)
    fmt.Println(num, err) // 255 <nil>

    num, err = strconv.ParseInt("0xFF", 0, 0)
    fmt.Println(num, err) // 255 <nil>
}

字符串解析为无符号整数 ParseUint

// ParseUint 类似 ParseInt 但不接受正负号，用于无符号整型
func ParseUint(s string, base int, bitSize int) (n uint64, err error)

✏️ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    num, err := strconv.ParseUint("FF", 16, 8)
    fmt.Println(num, err) // 255 <nil>
}

字符串解析为浮点数 ParseFloat

// 将字符串解析为浮点数，如果 s 符合语法规则，会返回一个最为接近 s 表示值得浮点数（IEEE754 规范舍入）
// bitSize 指定解析结果的浮点数类型，32 是 float32，64 是 float64
// 返回值 err 是 *NumErr 类型的，语法有误时，err.Error = ErrSyntax；结果超出表示范围时，返回值 f 为 ±Inf，err.Error= ErrRange
func ParseFloat(s string, bitSize int) (f float64, err error)

???? 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    s := "0.12345678901234567890"
    f, err := strconv.ParseFloat(s, 32)
    fmt.Println(f, err)          // 0.12345679104328156 <nil>
    fmt.Println(float32(f), err) // 0.12345679 <nil>

    f, err = strconv.ParseFloat(s, 64)
    fmt.Println(f, err) // 0.12345678901234568 <nil>
}

Format 类型

布尔值转换为字符串 FormatBool

// 根据 b 的值返回字符串 "true" 或 "false"
func FormatBool(b bool) string

✌ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    fmt.Printf("%q\n", strconv.FormatBool(0 < 1)) // "true"
    fmt.Printf("%q\n", strconv.FormatBool(0 > 1)) // "false"
}

有符号整数转换为字符串 FormatInt

// 将有符号整数转换为 base 进制的字符串。base 必须在 2 到 36 之间，结果中会使用到小写字母 'a' 到 'z'
func FormatInt(i int64, base int) string

✍ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    i := int64(-2048)
    fmt.Printf("%q\n", strconv.FormatInt(i, 2))  // "-100000000000"
    fmt.Printf("%q\n", strconv.FormatInt(i, 8))  // "-4000"
    fmt.Printf("%q\n", strconv.FormatInt(i, 10)) // "-2048"
    fmt.Printf("%q\n", strconv.FormatInt(i, 16)) // "-800"
    fmt.Printf("%q\n", strconv.FormatInt(i, 36)) // "-1kw"
}

无符号整数转换为字符串 FormatUint

// FormatInt 的无符号整数版本
func FormatUint(i uint64, base int) string

✍ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    i := uint64(2048)
    fmt.Printf("%q\n", strconv.FormatUint(i, 2))  // "100000000000"
    fmt.Printf("%q\n", strconv.FormatUint(i, 8))  // "4000"
    fmt.Printf("%q\n", strconv.FormatUint(i, 10)) // "2048"
    fmt.Printf("%q\n", strconv.FormatUint(i, 16)) // "800"
    fmt.Printf("%q\n", strconv.FormatUint(i, 36)) // "1kw"
}

浮点数转换为字符串 FormatFloat

// 将浮点数 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

???? 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    f := 100.12345678901234567890123456789
    fmt.Println(strconv.FormatFloat(f, 'b', 5, 32))  // 13123382p-17
    fmt.Println(strconv.FormatFloat(f, 'e', 5, 32))  // 1.00123e+02
    fmt.Println(strconv.FormatFloat(f, 'E', 5, 32))  // 1.00123E+02
    fmt.Println(strconv.FormatFloat(f, 'f', 5, 32))  // 100.12346
    fmt.Println(strconv.FormatFloat(f, 'g', 5, 32))  // 100.12
    fmt.Println(strconv.FormatFloat(f, 'G', 5, 32))  // 100.12
    fmt.Println(strconv.FormatFloat(f, 'b', 30, 32)) // 13123382p-17
    fmt.Println(strconv.FormatFloat(f, 'e', 30, 32)) // 1.001234588623046875000000000000e+02
    fmt.Println(strconv.FormatFloat(f, 'E', 30, 32)) // 1.001234588623046875000000000000E+02
    fmt.Println(strconv.FormatFloat(f, 'f', 30, 32)) // 100.123458862304687500000000000000
    fmt.Println(strconv.FormatFloat(f, 'g', 30, 32)) // 100.1234588623046875
    fmt.Println(strconv.FormatFloat(f, 'G', 30, 32)) // 100.1234588623046875
    fmt.Println(strconv.FormatFloat(f, 'g', -1, 32)) // 100.12346
}

string 和 int 互相转换

字符串解析为整数 Atoi

// 将字符串解析为整数，是 ParseInt(s, 10, 0) 的简写
func Atoi(s string) (i int, err error)

☕️ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 64 位的计算机
    num, err := strconv.Atoi("9223372036854775807")
    fmt.Println(num, err) // 9223372036854775807 <nil>

    num, err = strconv.Atoi("9223372036854775808")
    fmt.Println(num, err) // 9223372036854775807 strconv.Atoi: parsing "9223372036854775808": value out of range
}

整数转换为字符串 Itoa

// 将整数转换为字符串，是 FormatInt(i, 10) 的简写
func Itoa(i int) string

⭐️ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    fmt.Println(strconv.Itoa(-2048)) // -2048
    fmt.Println(strconv.Itoa(2048))  // 2048
}

其它函数

判断字符是否可显示 isPrint

// 判断字符 r 是否是一个可显示的字符
func IsPrint(r rune) bool

✏️ 示例代码

package main

import (
    "fmt"
    "strconv"
)

func main() {
    fmt.Println(strconv.IsPrint('a'))  // true
    fmt.Println(strconv.IsPrint('好'))  // true
    fmt.Println(strconv.IsPrint(' '))  // true
    fmt.Println(strconv.IsPrint('\t')) // false
    fmt.Println(strconv.IsPrint('\n')) // false
}