### ParseBool
~~~
func ParseBool(str string) (bool, error)
~~~
**ParseBool 将字符串转换为布尔值**
它接受真值：1, t, T, TRUE, true, True
它接受假值：0, f, F, FALSE, false, False.
其它任何值都返回一个错误
示例
~~~
package main
import (
"fmt"
"strconv"
)
func main() {
b, err := strconv.ParseBool("t")
if err == nil{
fmt.Println(b)
}else{
fmt.Println(err)
}
}
~~~
### FormatBool
**将布尔值转换为字符串 "true" 或 "false"**
~~~
res := strconv.FormatBool(0 > 1)
fmt.Println(res)
~~~
### ParseFloat
```
func ParseFloat(s string, bitSize int) (f float64, err error)
```
**ParseFloat 将字符串转换为浮点数**
s：要转换的字符串
bitSize：指定浮点类型（32:float32、64:float64）
如果 s 是合法的格式，而且接近一个浮点值，
则返回浮点数的四舍五入值（依据 IEEE754 的四舍五入标准）
如果 s 不是合法的格式，则返回“语法错误”
如果转换结果超出 bitSize 范围，则返回“超出范围”
~~~
s := "3.1415926"
f, err := strconv.ParseFloat(s, 64)
if err == nil{
fmt.Println(f) // 3.1415926
}else{
fmt.Println(err)
}
~~~
### ParseInt
~~~
func ParseInt(s string, base int, bitSize int) (i int64, err error)
~~~
**ParseInt 将字符串转换为 int 类型**
s：要转换的字符串
base：进位制（2 进制到 36 进制）
bitSize：指定整数类型（0:int、8:int8、16:int16、32:int32、64:int64）
返回转换后的结果和转换时遇到的错误
如果 base 为 0，则根据字符串的前缀判断进位制（0x:16，0:8，其它:10）
~~~
s := "0101"
i, err := strconv.ParseInt(s, 2, 0)
fmt.Println(err, i) // 5
s = "233"
i, err = strconv.ParseInt(s, 0, 0)
fmt.Println(err, i) // 233
~~~
### ParseUint
```
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
```
**ParseUint 功能同 ParseInt 一样，只不过返回 uint 类型整数**
~~~
fmt.Println(strconv.ParseUint("FF", 16, 8)) // 255 <nil>
~~~
### Atoi
~~~
func Atoi(s string) (int, error)
~~~
**Atoi 相当于 ParseInt(s, 10, 0)**
通常使用这个函数，而不使用 ParseInt
~~~
fmt.Println(strconv.Atoi("518")) // 518 <nil>
~~~
### FormatFloat
```
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
```
**FormatFloat 将浮点数 f 转换为字符串值**
f：要转换的浮点数
fmt：格式标记（b、e、E、f、g、G）
prec：精度（数字部分的长度，不包括指数部分）
bitSize：指定浮点类型（32:float32、64:float64）
格式标记：
'b' (-ddddp±ddd，二进制指数)
'e' (-d.dddde±dd，十进制指数)
'E' (-d.ddddE±dd，十进制指数)
'f' (-ddd.dddd，没有指数)
'g' ('e':大指数，'f':其它情况)
'G' ('E':大指数，'f':其它情况)
如果格式标记为 'e'，'E'和'f'，则 prec 表示小数点后的数字位数
如果格式标记为 'g'，'G'，则 prec 表示总的数字位数（整数部分+小数部分）
~~~
f := 100.123456789
fmt.Println(strconv.FormatFloat(f, 'g', 5, 64))
// 100.12
fmt.Println(strconv.FormatFloat(f, 'G', 5, 64))
// 100.12
fmt.Println(strconv.FormatFloat(f, 'f', 5, 64))
// 100.12346
fmt.Println(strconv.FormatFloat(f, 'e', 5, 64))
// 1.00123e+02
fmt.Println(strconv.FormatFloat(f, 'E', 5, 64))
// 1.00123E+02
~~~
### FormatInt
```
func FormatInt(i int64, base int) string
```
**FormatInt 将 int 型整数 i 转换为字符串形式**
base：进位制（2 进制到 36 进制）
大于 10 进制的数，返回值使用小写字母 'a' 到 'z'
~~~
i := int64(100)
fmt.Println(strconv.FormatInt(i, 10))
// 100
fmt.Println(strconv.FormatInt(i, 2))
// 1100100
fmt.Println(strconv.FormatInt(i, 16))
// 64
~~~
### Itoa
```
func Itoa(i int) string
```
**Itoa 相当于 FormatInt(i, 10) **
~~~
func main() {
fmt.Println(strconv.Itoa(-2048)) // -2048
fmt.Println(strconv.Itoa(2048)) // 2048
}
~~~
### FormatUint
```
func FormatUint(i uint64, base int) string
```
**FormatUint 将 uint 型整数 i 转换为字符串形式**
base：进位制（2 进制到 36 进制）
大于 10 进制的数，返回值使用小写字母 'a' 到 'z'
~~~
func main() {
i := uint64(2048)
fmt.Println(strconv.FormatUint(i, 2)) // 100000000000
fmt.Println(strconv.FormatUint(i, 8)) // 4000
fmt.Println(strconv.FormatUint(i, 10)) // 2048
fmt.Println(strconv.FormatUint(i, 16)) // 800
fmt.Println(strconv.FormatUint(i, 36)) // 1kw
}
~~~
