Go 語(yǔ)言字符串使用方式與技巧
01 、介紹
關(guān)于 Go 語(yǔ)言字符串的使用，我們需要了解標(biāo)準(zhǔn)庫(kù) strconv 和標(biāo)準(zhǔn)庫(kù) strings 的使用方式，它們分別用于字符串類型轉(zhuǎn)換和字符串操作。
本文我們重點(diǎn)介紹 Go 語(yǔ)言字符串使用方式與技巧。
02 、字符串類型轉(zhuǎn)換
Go 語(yǔ)言是強(qiáng)類型語(yǔ)言，在使用 Go 語(yǔ)言時(shí)，通常會(huì)遇到需要將字符串與其它類型相互轉(zhuǎn)換的場(chǎng)景。
此時(shí)，我們可以使用標(biāo)準(zhǔn)庫(kù) strconv。
字符串 to 布爾
示例代碼：
func main() {
v := "true"
if s, err := strconv.ParseBool(v); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
}輸出結(jié)果：
bool, true閱讀上面這段代碼，我們使用 func ParseBool(str string) (bool, error) 將字符串轉(zhuǎn)換為布爾。需要注意的是，該函數(shù)接收參數(shù)的值是有限制的，除了 1、t、T、TRUE、true、True、0、f、F、FALSE、false、False 之外，其它任何值都會(huì)返回 error。
字符串 to 浮點(diǎn)型
示例代碼：
func main() {
v := "3.1415926535"
if s, err := strconv.ParseFloat(v, 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat(v, 64); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("NaN", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
// ParseFloat is case insensitive
if s, err := strconv.ParseFloat("nan", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("inf", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("+Inf", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("-Inf", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("-0", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
if s, err := strconv.ParseFloat("+0", 32); err == nil {
fmt.Printf("%T, %v\n", s, s)
}
}輸出結(jié)果：
float64, 3.1415927410125732
float64, 3.1415926535
float64, NaN
float64, NaN
float64, +Inf
float64, +Inf
float64, -Inf
float64, -0
float64, 0閱讀上面這段代碼，我們使用 func ParseFloat(s string, bitSize int) (float64, error) 將字符串轉(zhuǎn)換為 64 位浮點(diǎn)數(shù)。需要注意的是，該函數(shù)接收參數(shù)可以識(shí)別值為 NaN、Inf（有符號(hào) +Inf 或 -Inf），并且忽略它們的大小寫。
字符串 to 整型
示例代碼：
func main() {
v32 := "-354634382"
if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
fmt.Printf("s:%T, %v\n", s, s)
}
if s1, err := strconv.ParseInt(v32, 16, 32); err == nil {
fmt.Printf("s1:%T, %v\n", s1, s1)
}
v64 := "-3546343826724305832"
if s2, err := strconv.ParseInt(v64, 10, 64); err == nil {
fmt.Printf("s2:%T, %v\n", s2, s2)
}
if s3, err := strconv.ParseInt(v64, 16, 64); err == nil {
fmt.Printf("s3:%T, %v\n", s3, s3)
}
}輸出結(jié)果：
s:int64, -354634382
s2:int64, -3546343826724305832閱讀上面這段代碼，我們使用 func ParseInt(s string, base int, bitSize int) (i int64, err error) 將字符串轉(zhuǎn)換為整型。
需要注意的是，該函數(shù)的第一個(gè)入?yún)樽址愋偷臄?shù)值，可以 "+" 或 "-" 符號(hào)開(kāi)頭；
第二個(gè)參數(shù)指定進(jìn)制，它的值如果是 0，進(jìn)制則以第一個(gè)參數(shù)符號(hào)后的前綴決定，例如："0b" 為 2，"0" 或 "0o" 為 8，"0x" 為 16，否則為 10；
第三個(gè)參數(shù)指定返回結(jié)果必須符合整數(shù)類型的取值范圍，它的值為 0、8、16、32 和 64，分別代表 int、int8、int16、int32 和 int64。
細(xì)心的讀者朋友們可能已經(jīng)發(fā)現(xiàn)，示例代碼中，第 2 和 第 4 返回錯(cuò)誤，原因是第二個(gè)參數(shù)指定的進(jìn)制與第一個(gè)參數(shù)的數(shù)值不相符，超出取值范圍。
此外，函數(shù) func ParseUint(s string, base int, bitSize int) (uint64, error) 與之類似，但是用于無(wú)符號(hào)整數(shù)。
在實(shí)際項(xiàng)目開(kāi)發(fā)中，十進(jìn)制使用的最多，所以標(biāo)準(zhǔn)庫(kù) strconv 提供了函數(shù) func Atoi(s string) (int, error)，它的功能類似 ParseInt(s, 10, 0)，需要注意的是，它的返回值類型是 int（需要注意取值范圍），而不是 int64。
布爾 to 字符串
示例代碼：
func main() {
v := true
s := strconv.FormatBool(v)
fmt.Printf("%T, %v\n", s, s)
}輸出結(jié)果：
string, true閱讀上面這段代碼，我們使用 func FormatBool(b bool) string 將布爾轉(zhuǎn)換為字符串。
浮點(diǎn)型 to 字符串
示例代碼：
func main() {
v := 3.1415926535
s32 := strconv.FormatFloat(v, 'E', -1, 32)
fmt.Printf("%T, %v\n", s32, s32)
s64 := strconv.FormatFloat(v, 'E', -1, 64)
fmt.Printf("%T, %v\n", s64, s64)
fmt64 := strconv.FormatFloat(v, 'g', -1, 64)
fmt.Printf("%T, %v\n", fmt64, fmt64)
}輸出結(jié)果：
string, 3.1415927E+00
string, 3.1415926535E+00
string, 3.1415926535閱讀上面這段代碼，我們使用 func FormatFloat(f float64, fmt byte, prec, bitSize int) string 將浮點(diǎn)型轉(zhuǎn)換為字符串。該函數(shù)包含 4 個(gè)參數(shù)，第一個(gè)參數(shù)是需要轉(zhuǎn)換的浮點(diǎn)數(shù)；第二個(gè)參數(shù)是進(jìn)制；第三個(gè)參數(shù)是精度，第四個(gè)參數(shù)是轉(zhuǎn)換后值的取值范圍。
其中，第二個(gè)參數(shù) b 代表二進(jìn)制指數(shù)；e 或 E 代表十進(jìn)制指數(shù)；f 代表無(wú)進(jìn)制指數(shù)；g 或 G 代表指數(shù)大時(shí) 為 e，反之為 f；x 或 X 代表十六進(jìn)制分?jǐn)?shù)和二進(jìn)制指數(shù)。
第三個(gè)參數(shù)，精度 prec 控制由 'e'，'E'，'f'，'g'，'G'，'x' 和 'X' 格式打印的位數(shù)(不包括指數(shù))。對(duì)于 'e'，'E'，'f'，'x' 和 'X'，它是小數(shù)點(diǎn)后的位數(shù)。對(duì)于 'g' 和 'G'，它是有效數(shù)字的最大數(shù)目(去掉后面的零)。特殊精度 -1 使用所需的最小位數(shù)，以便 ParseFloat 精確返回 f。
整型 to 字符串
示例代碼：
func main() {
v := int64(-42)
s10 := strconv.FormatInt(v, 10)
fmt.Printf("%T, %v\n", s10, s10)
s16 := strconv.FormatInt(v, 16)
fmt.Printf("%T, %v\n", s16, s16)
}輸出結(jié)果：
string, -42
string, -2a閱讀上面這段代碼，我們使用 func FormatInt(i int64, base int) string 將整型轉(zhuǎn)換為字符串。需要注意的是，第二個(gè)參數(shù)的取值范圍 2 <= base <= 36。
此外，函數(shù) func FormatUint(i uint64, base int) string 與之功能類型，區(qū)別是僅用于轉(zhuǎn)換無(wú)類型整數(shù)。
在實(shí)際項(xiàng)目開(kāi)發(fā)中，十進(jìn)制使用的最多，所以標(biāo)準(zhǔn)庫(kù) strconv 提供了函數(shù) func Itoa(i int) string，它的功能類似 FormatInt(int64(i), 10)，需要注意的是，該函數(shù)入?yún)⒌念愋褪?nbsp;int。
03 、字符串操作
關(guān)于字符串操作，標(biāo)準(zhǔn)庫(kù) strings 提供了相關(guān)函數(shù)，我們介紹幾個(gè)常用的函數(shù)。
字符串中是否包含指定字符串
示例代碼：
func main() {
fmt.Println(strings.Contains("seafood", "foo"))
fmt.Println(strings.Contains("seafood", "bar"))
fmt.Println(strings.Contains("seafood", ""))
fmt.Println(strings.Contains("", ""))
}輸出結(jié)果：
true
false
true
true閱讀上面這段代碼，我們使用 func Contains(s, substr string) bool 在字符串 substr 中查找 s，存在則返回 true，反之返回 false。
字符串中是否包含指定字符串中任意字符
示例代碼：
func main() {
fmt.Println(strings.ContainsAny("team", "i"))
fmt.Println(strings.ContainsAny("fail", "ui"))
fmt.Println(strings.ContainsAny("ure", "ui"))
fmt.Println(strings.ContainsAny("failure", "ui"))
fmt.Println(strings.ContainsAny("foo", ""))
fmt.Println(strings.ContainsAny("", ""))
}輸出結(jié)果：
false
true
true
true
false
false閱讀上面這段代碼，我們使用 func ContainsAny(s, chars string) bool 在字符串 s 中查找是否包含字符串 chars 中任意字符，存在則返回 true，反之返回 false。
刪除字符串中指定字符
示例代碼：
func main() {
fmt.Print(strings.Trim("???Hello, Gophers!!!", "!?"))
}輸出結(jié)果：
Hello, Gophers閱讀上面這段代碼，我們使用 func Trim(s, cutset string) string 刪除字符串 s 中的字符 cutset。
字符串轉(zhuǎn)換為大寫
示例代碼：
func main() {
fmt.Println(strings.ToUpper("Gopher"))
}輸出結(jié)果：
GOPHER閱讀上面這段代碼，我們使用 func ToUpper(s string) string 將字符串中的字符全部轉(zhuǎn)換為大寫。
字符串以指定字符拆分為字符串切片
示例代碼：
func main() {
fmt.Printf("%q\n", strings.Split("a,b,c", ","))
fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
fmt.Printf("%q\n", strings.Split(" xyz ", ""))
fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
}輸出結(jié)果：
["a" "b" "c"]
["" "man " "plan " "canal panama"]
[" " "x" "y" "z" " "]
[""]閱讀上面這段代碼，我們使用 func Split(s, sep string) []string 將字符串 s 以字符串 sep 為分隔符，拆分為字符串切片。
字符串切片拼接為字符串
示例代碼：
func main() {
s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ", "))
}輸出結(jié)果：
foo, bar, baz閱讀上面這段代碼，我們使用 func Join(elems []string, sep string) string 將字符串切片中的所有元素，以 sep 為分隔符，拼接為字符串。
04 、字符串拼接
關(guān)于字符串拼接，分為編譯時(shí)字符串拼接，和運(yùn)行時(shí)字符串拼接。
其中，編譯時(shí)字符串拼接，即使用 + 將多個(gè)字符串拼接為一個(gè)字符串，需要注意的是，在使用 + 拼接字符串時(shí)，如果存在字符串變量，則會(huì)在運(yùn)行時(shí)拼接。
示例代碼：
func main() {
str := "hello" + " world"
fmt.Println(str)
name := "frank"
outPut := "My name is " + name
fmt.Println(outPut)
}輸出結(jié)果：
hello world
My name is frank閱讀上面這段代碼，第一個(gè)字符串拼接是在編譯時(shí)拼接，第二個(gè)字符串拼接是在運(yùn)行時(shí)拼接。
需要注意的是，運(yùn)行時(shí)拼接是分配一塊新的內(nèi)存空間，通過(guò)內(nèi)存拷貝的方式將字符串拷貝到新內(nèi)存空間。
如果拼接后的字符串小于 32 字節(jié)，可以使用臨時(shí)緩存；如果拼接后的字符串大于 32 字節(jié)，需要在堆區(qū)分配一塊內(nèi)存空間，并將需要拼接的多個(gè)字符串通過(guò)內(nèi)存拷貝的形式拷貝過(guò)去。
字符串與字節(jié)數(shù)組互相轉(zhuǎn)換時(shí)，也需要通過(guò)內(nèi)存拷貝的方式，如果字符串大于 32 字節(jié)，需要在堆區(qū)分配一塊內(nèi)存空間，所以在一些轉(zhuǎn)換密集的場(chǎng)景，我們需要特別注意。
此外，除了使用操作符 + 或 += 拼接字符串之外，還有多種字符串拼接方式，例如，fmt.Sprintf、bytes.Buffer、strings.Join 和 stings.Builder。這些字符串拼接方式在之前的文章 「Golang 語(yǔ)言怎么高效拼接字符串？」 介紹過(guò)，本文不再贅述。
05 、總結(jié)
本文我們介紹 Go 語(yǔ)言中字符串的使用方式，包括類型轉(zhuǎn)換、字符串操作、字符串拼接。
除了使用標(biāo)準(zhǔn)庫(kù) strconv 進(jìn)行字符串類型轉(zhuǎn)換之外，讀者朋友們也可以選擇三方庫(kù)，例如：github.com/spf13/cast。
建議讀者朋友們閱讀標(biāo)準(zhǔn)庫(kù)文檔，了解更多關(guān)于標(biāo)準(zhǔn)庫(kù) strconv 和 strings 的函數(shù)。
