### 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
}
~~~
