strings 和 strconv 包

作為一種基本資料結構，每種語言都有一些對於字串的預定義處理函式。Go 中使用 strings 包來完成對字串的主要操作。

字首和字尾

HasPrefix 判斷字串 s 是否以 prefix 開頭：

strings.HasPrefix(s, prefix string) bool

HasSuffix 判斷字串 s 是否以 suffix 結尾：

strings.HasSuffix(s, suffix string) bool

例項

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str string = "This is an example of a string"
    fmt.Printf("T/F? Does the string \"%s\" have prefix %s? ", str, "Th")
    fmt.Printf("%t\n", strings.HasPrefix(str, "Th"))
}

輸出：

T/F? Does the string "This is an example of a string" have prefix Th? true

這個例子同樣演示了轉義字元 \ 和格式化字串的使用。

字串包含關係

Contains 判斷字串 s 是否包含 substr：

strings.Contains(s, substr string) bool

判斷子字串或字元在父字串中出現的位置（索引）

Index 返回字串 str 在字串 s 中的索引（str 的第一個字元的索引），-1 表示字串 s 不包含字串 str：

strings.Index(s, str string) int

LastIndex 返回字串 str 在字串 s 中最後出現位置的索引（str 的第一個字元的索引），-1 表示字串 s 不包含字串 str：

strings.LastIndex(s, str string) int

如果 ch 是非 ASCII 編碼的字元，建議使用以下函式來對字元進行定位：

strings.IndexRune(s string, r rune) int

示例

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str string = "Hi, I'm Marc, Hi."

    fmt.Printf("The position of \"Marc\" is: ")
    fmt.Printf("%d\n", strings.Index(str, "Marc"))

    fmt.Printf("The position of the first instance of \"Hi\" is: ")
    fmt.Printf("%d\n", strings.Index(str, "Hi"))
    fmt.Printf("The position of the last instance of \"Hi\" is: ")
    fmt.Printf("%d\n", strings.LastIndex(str, "Hi"))

    fmt.Printf("The position of \"Burger\" is: ")
    fmt.Printf("%d\n", strings.Index(str, "Burger"))
}

輸出：

The position of "Marc" is: 8
The position of the first instance of "Hi" is: 0
The position of the last instance of "Hi" is: 14
The position of "Burger" is: -1

字串替換

Replace 用於將字串 str 中的前 n 個字串 old 替換為字串 new，並返回一個新的字串，如果 n = -1 則替換所有字串 old 為字串 new：

strings.Replace(str, old, new, n) string

統計字串出現次數

Count 用於計算字串 str 在字串 s 中出現的非重疊次數：

strings.Count(s, str string) int

示例

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str string = "Hello, how is it going, Hugo?"
    var manyG = "gggggggggg"

    fmt.Printf("Number of H's in %s is: ", str)
    fmt.Printf("%d\n", strings.Count(str, "H"))

    fmt.Printf("Number of double g's in %s is: ", manyG)
    fmt.Printf("%d\n", strings.Count(manyG, "gg"))
}

輸出：

Number of H's in Hello, how is it going, Hugo? is: 2
Number of double g’s in gggggggggg is: 5

重複字串

Repeat 用於重複 count 次字串 s 並返回一個新的字串：

strings.Repeat(s, count int) string

示例

package main

import (
    "fmt"
    "strings"
)

func main() {
    var origS string = "Hi there! "
    var newS string

    newS = strings.Repeat(origS, 3)
    fmt.Printf("The new repeated string is: %s\n", newS)
}

輸出：

The new repeated string is: Hi there! Hi there! Hi there!

修改字串大小寫

ToLower 將字串中的 Unicode 字元全部轉換為相應的小寫字元：

strings.ToLower(s) string

ToUpper 將字串中的 Unicode 字元全部轉換為相應的大寫字元：

strings.ToUpper(s) string

示例

package main

import (
    "fmt"
    "strings"
)

func main() {
    var orig string = "Hey, how are you George?"
    var lower string
    var upper string

    fmt.Printf("The original string is: %s\n", orig)
    lower = strings.ToLower(orig)
    fmt.Printf("The lowercase string is: %s\n", lower)
    upper = strings.ToUpper(orig)
    fmt.Printf("The uppercase string is: %s\n", upper)
}

輸出：

The original string is: Hey, how are you George?
The lowercase string is: hey, how are you george?
The uppercase string is: HEY, HOW ARE YOU GEORGE?

修剪字串

你可以使用 strings.TrimSpace(s) 來剔除字串開頭和結尾的空白符號；如果你想要剔除指定字元，則可以使用 strings.Trim(s, "cut") 來將開頭和結尾的 cut 去除掉。該函式的第二個引數可以包含任何字元，如果你只想剔除開頭或者結尾的字串，則可以使用 TrimLeft 或者 TrimRight 來實現。

分割字串

strings.Fields(s) 將會利用 1 個或多個空白符號來作為動態長度的分隔符將字串分割成若干小塊，並返回一個 slice，如果字串只包含空白符號，則返回一個長度為 0 的 slice。

strings.Split(s, sep) 用於自定義分割符號來對指定字串進行分割，同樣返回 slice。

因為這 2 個函式都會返回 slice，所以習慣使用 for-range 迴圈來對其進行處理。

拼接 slice 到字串

Join 用於將元素型別為 string 的 slice 使用分割符號來拼接組成一個字串：

strings.Join(sl []string, sep string) string

示例

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "The quick brown fox jumps over the lazy dog"
    sl := strings.Fields(str)
    fmt.Printf("Splitted in slice: %v\n", sl)
    for _, val := range sl {
        fmt.Printf("%s - ", val)
    }
    fmt.Println()
    str2 := "GO1|The ABC of Go|25"
    sl2 := strings.Split(str2, "|")
    fmt.Printf("Splitted in slice: %v\n", sl2)
    for _, val := range sl2 {
        fmt.Printf("%s - ", val)
    }
    fmt.Println()
    str3 := strings.Join(sl2,";")
    fmt.Printf("sl2 joined by ;: %s\n", str3)
}

輸出：

Splitted in slice: [The quick brown fox jumps over the lazy dog]
The - quick - brown - fox - jumps - over - the - lazy - dog -
Splitted in slice: [GO1 The ABC of Go 25]
GO1 - The ABC of Go - 25 -
sl2 joined by ;: GO1;The ABC of Go;25

其它有關字串操作的文件請參閱 官方文件。

從字串中讀取內容

函式 strings.NewReader(str) 用於生成一個 Reader 並讀取字串中的內容，然後返回指向該 Reader 的指標，從其它型別讀取內容的函式還有：

• Read() 從 []byte 中讀取內容。
• ReadByte() 和 ReadRune() 從字串中讀取下一個 byte 或者 rune。

字串與其它型別的轉換

與字串相關的型別轉換都是通過 strconv 包實現的。

該包包含了一些變數用於獲取程式執行的作業系統平臺下 int 型別所佔的位數，如：strconv.IntSize。

任何型別 T 轉換為字串總是成功的。

針對從數字型別轉換到字串，Go 提供了以下函式：

• strconv.Itoa(i int) string 返回數字 i 所表示的字串型別的十進位制數。
• strconv.FormatFloat(f float64, fmt byte, prec int, bitSize int) string 將 64 位浮點型的數字轉換為字串，其中 fmt 表示格式（其值可以是 'b'、'e'、'f' 或 'g'），prec 表示精度，bitSize 則使用 32 表示 float32，用 64 表示 float64。

將字串轉換為其它型別 tp 並不總是可能的，可能會在執行時丟擲錯誤 parsing "…": invalid argument。

針對從字串型別轉換為數字型別，Go 提供了以下函式：

• strconv.Atoi(s string) (i int, err error) 將字串轉換為 int 型。
• strconv.ParseFloat(s string, bitSize int) (f float64, err error) 將字串轉換為 float64 型。

利用多返回值的特性，這些函式會返回 2 個值，第 1 個是轉換後的結果（如果轉換成功），第 2 個是可能出現的錯誤，因此，我們一般使用以下形式來進行從字串到其它型別的轉換：

val, err = strconv.Atoi(s)

在下面這個示例中，我們忽略可能出現的轉換錯誤：

示例

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var orig string = "666"
    var an int
    var newS string

    fmt.Printf("The size of ints is: %d\n", strconv.IntSize)      

    an, _ = strconv.Atoi(orig)
    fmt.Printf("The integer is: %d\n", an) 
    an = an + 5
    newS = strconv.Itoa(an)
    fmt.Printf("The new string is: %s\n", newS)
}

輸出：

64 位系統：
The size of ints is: 64
32 位系統：
The size of ints is: 32
The integer is: 666
The new string is: 671