14. 字串

什麼是字串？

Go 語言中的字串是一個位元組切片。把內容放在雙引號""之間，我們可以建立一個字串。讓我們來看一個建立並列印字串的簡單示例。

package main

import (
    "fmt"
)

func main() {
    name := "Hello World"
    fmt.Println(name)
}

上面的程式將會輸出 Hello World。

Go 中的字串是相容 Unicode 編碼的，並且使用 UTF-8 進行編碼。

單獨獲取字串的每一個位元組

由於字串是一個位元組切片，所以我們可以獲取字串的每一個位元組。

package
 
 main

import (
    "fmt"
)

func printBytes(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
}

上面程式的第 8 行，len(s) 返回字串中位元組的數量，然後我們用了一個 for 迴圈以 16 進位制的形式列印這些位元組。%x 格式限定符用於指定 16 進位制編碼。上面的程式輸出 48 65 6c 6c 6f 20 57 6f 72 6c 64

讓我們稍微修改一下上面的程式，讓它列印字串的每一個字元。

package main

import (
    "fmt"
)

func printBytes(s string) {
    for
 
 i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}


func printChars(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%c ",s[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
}

在 printChars 方法(第 16 行中)中，%c 格式限定符用於列印字串的字元。這個程式輸出結果是：

48 65 6c 6c 6f 20 57 6f 72 6c 64  
H e l l o   W o r l d

上面的程式獲取字串的每一個字元，雖然看起來是合法的，但卻有一個嚴重的 bug。讓我拆解這個程式碼來看看我們做錯了什麼。

package main

import (
    "fmt"
)

func printBytes(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}

func printChars(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%c ",s[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
    fmt.Printf("\n")
    name = "Señor"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
}

上面程式碼輸出的結果是：

48 65 6c 6c 6f 20 57 6f 72 6c 64  
H e l l o   W o r l d  
53 65 c3 b1 6f 72  
S e à ± o r

在上面程式的第 28 行，我們嘗試輸出 Señor 的字元，但卻輸出了錯誤的 S e à ± o r。 為什麼程式分割 Hello World 時表現完美，但分割 Señor 就出現了錯誤呢？這是因為 ñ 的 Unicode 程式碼點（Code Point）是 U+00F1。它的 [UTF-8 編碼]佔用了 c3 和 b1 兩個位元組。它的 UTF-8 編碼佔用了兩個位元組 c3 和 b1。而我們列印字元時，卻假定每個字元的編碼只會佔用一個位元組，這是錯誤的。在 UTF-8 編碼中，一個程式碼點可能會佔用超過一個位元組的空間。那麼我們該怎麼辦呢？rune 能幫我們解決這個難題。

rune

rune 是 Go 語言的內建型別，它也是 int32 的別稱。在 Go 語言中，rune 表示一個程式碼點。程式碼點無論佔用多少個位元組，都可以用一個 rune 來表示。讓我們修改一下上面的程式，用 rune 來列印字元。

package main

import (
    "fmt"
)

func printBytes(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}

func printChars(s string) {
    runes := []rune(s)
    for i:= 0; i < len(runes); i++ {
        fmt.Printf("%c ",runes[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
    fmt.Printf("\n\n")
    name = "Señor"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
}

在上面程式碼的第 14 行，字串被轉化為一個 rune 切片。然後我們迴圈列印字元。程式的輸出結果是

48 65 6c 6c 6f 20 57 6f 72 6c 64  
H e l l o   W o r l d 

53 65 c3 b1 6f 72  
S e ñ o r

上面的輸出結果非常完美，就是我們想要的結果:)。

字串的 for range 迴圈

上面的程式是一種遍歷字串的好方法，但是 Go 給我們提供了一種更簡單的方法來做到這一點：使用 for range 迴圈。

package main

import (
    "fmt"
)

func printCharsAndBytes(s string) {
    for index, rune := range s {
        fmt.Printf("%c starts at byte %d\n", rune, index)
    }
}

func main() {
    name := "Señor"
    printCharsAndBytes(name)
}

在上面程式中的第8行，使用 for range 迴圈遍歷了字串。迴圈返回的是是當前 rune 的位元組位置。程式的輸出結果為：

S starts at byte 0  
e starts at byte 1  
ñ starts at byte 2
o starts at byte 4  
r starts at byte 5

從上面的輸出中可以清晰的看到 ñ 佔了兩個位元組:)。

用位元組切片構造字串

package main

import (  
    "fmt"
)

func main() {  
    byteSlice := []byte{0x43, 0x61, 0x66, 0xC3, 0xA9}
    str := string(byteSlice)
    fmt.Println(str)
}

上面的程式中 byteSlice 包含字串 Café 用 UTF-8 編碼後的 16 進位制位元組。程式輸出結果是 Café。

如果我們把 16 進位制換成對應的 10 進位制值會怎麼樣呢？上面的程式還能工作嗎？讓我們來試一試：

package main

import (  
    "fmt"
)

func main() {  
    byteSlice := []byte{67, 97, 102, 195, 169}//decimal equivalent of {'\x43', '\x61', '\x66', '\xC3', '\xA9'}
    str := string(byteSlice)
    fmt.Println(str)
}

上面程式的輸出結果也是Café

用 rune 切片構造字串

package main

import (  
    "fmt"
)

func main() {  
    runeSlice := []rune{0x0053, 0x0065, 0x00f1, 0x006f, 0x0072}
    str := string(runeSlice)
    fmt.Println(str)
}

在上面的程式中 runeSlice 包含字串 Señor的 16 進位制的 Unicode 程式碼點。這個程式將會輸出Señor。

字串的長度

[utf8 package] 包中的 func RuneCountInString(s string) (n int) 方法用來獲取字串的長度。這個方法傳入一個字串引數然後返回字串中的 rune 的數量。

package main

import (  
    "fmt"
    "unicode/utf8"
)

func length(s string) {  
    fmt.Printf("length of %s is %d\n", s, utf8.RuneCountInString(s))
}
func main() { 
    word1 := "Señor" 
    length(word1)
    word2 := "Pets"
    length(word2)
}

上面程式的輸出結果是：

length of Señor is 5  
length of Pets is 4

字串是不可變的

Go 中的字串是不可變的。一旦一個字串被建立，那麼它將無法被修改。

package main

import (  
    "fmt"
)

func mutate(s string)string {  
    s[0] = 'a'//any valid unicode character within single quote is a rune 
    return s
}
func main() {  
    h := "hello"
    fmt.Println(mutate(h))
}

在上面程式中的第 8 行，我們試圖把這個字串中的第一個字元修改為 'a'。由於字串是不可變的，因此這個操作是非法的。所以程式丟擲了一個錯誤 main.go:8: cannot assign to s[0]。

為了修改字串，可以把字串轉化為一個 rune 切片。然後這個切片可以進行任何想要的改變，然後再轉化為一個字串。

package main

import (  
    "fmt"
)

func mutate(s []rune) string {  
    s[0] = 'a' 
    return string(s)
}
func main() {  
    h := "hello"
    fmt.Println(mutate([]rune(h)))
}

在上面程式的第 7 行，mutate 函式接收一個 rune 切片引數，它將切片的第一個元素修改為 'a'，然後將 rune 切片轉化為字串，並返回該字串。程式的第 13 行呼叫了該函式。我們把 h 轉化為一個 rune 切片，並傳遞給了 mutate。這個程式輸出 aello。