go 字符串

字符串

什么是字符串？

Go 語(yǔ)言中的字符串是一個(gè)字節(jié)切片。把內(nèi)容放在雙引號(hào)""之間，我們可以創(chuàng)建一個(gè)字符串。讓我們來看一個(gè)創(chuàng)建并打印字符串的簡(jiǎn)單示例。

package main

import (
    "fmt"
)

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

上面的程序?qū)?huì)輸出 Hello World。

Go 中的字符串是兼容 Unicode 編碼的，并且使用 UTF-8 進(jìn)行編碼。

單獨(dú)獲取字符串的每一個(gè)字節(jié)

由于字符串是一個(gè)字節(jié)切片，所以我們可以獲取字符串的每一個(gè)字節(jié)。

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) 返回字符串中字節(jié)的數(shù)量，然后我們用了一個(gè) for 循環(huán)以 16 進(jìn)制的形式打印這些字節(jié)。%x 格式限定符用于指定 16 進(jìn)制編碼。上面的程序輸出 48 65 6c 6c 6f 20 57 6f 72 6c 64。這些打印出來的字符是 "Hello World" 以 [Unicode UTF-8 編碼]的結(jié)果。為了更好的理解 go 中的字符串，需要對(duì) Unicode 和 UTF-8 有基礎(chǔ)的理解。我推薦閱讀一下 <https://naveenr.net/unicode-character-set-and-utf-8-utf-16-utf-32-encoding/> 來理解一下什么是 Unicode 和 UTF-8。

讓我們稍微修改一下上面的程序，讓它打印字符串的每一個(gè)字符。

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 格式限定符用于打印字符串的字符。這個(gè)程序輸出結(jié)果是：

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

上面的程序獲取字符串的每一個(gè)字符，雖然看起來是合法的，但卻有一個(gè)嚴(yán)重的 bug。讓我拆解這個(gè)代碼來看看我們做錯(cuò)了什么。

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)
}

上面代碼輸出的結(jié)果是：

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 的字符，但卻輸出了錯(cuò)誤的 S e ? ± o r。 為什么程序分割 Hello World 時(shí)表現(xiàn)完美，但分割 Se?or 就出現(xiàn)了錯(cuò)誤呢？這是因?yàn)?? 的 Unicode 代碼點(diǎn)（Code Point）是 U+00F1。它的 [UTF-8 編碼]占用了 c3 和 b1 兩個(gè)字節(jié)。它的 UTF-8 編碼占用了兩個(gè)字節(jié) c3 和 b1。而我們打印字符時(shí)，卻假定每個(gè)字符的編碼只會(huì)占用一個(gè)字節(jié)，這是錯(cuò)誤的。在 UTF-8 編碼中，一個(gè)代碼點(diǎn)可能會(huì)占用超過一個(gè)字節(jié)的空間。那么我們?cè)撛趺崔k呢？rune 能幫我們解決這個(gè)難題。

rune

rune 是 Go 語(yǔ)言的內(nèi)建類型，它也是 int32 的別稱。在 Go 語(yǔ)言中，rune 表示一個(gè)代碼點(diǎn)。代碼點(diǎn)無論占用多少個(gè)字節(jié)，都可以用一個(gè) 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 行，字符串被轉(zhuǎn)化為一個(gè) rune 切片。然后我們循環(huán)打印字符。程序的輸出結(jié)果是

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

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

字符串的 for range 循環(huán)

上面的程序是一種遍歷字符串的好方法，但是 Go 給我們提供了一種更簡(jiǎn)單的方法來做到這一點(diǎn)：使用 for range 循環(huán)。

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 循環(huán)遍歷了字符串。循環(huán)返回的是是當(dāng)前 rune 的字節(jié)位置。程序的輸出結(jié)果為：

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

從上面的輸出中可以清晰的看到 ? 占了兩個(gè)字節(jié):)。

用字節(jié)切片構(gòu)造字符串

package main

import (  
    "fmt"
)

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

上面的程序中 byteSlice 包含字符串 Café 用 UTF-8 編碼后的 16 進(jìn)制字節(jié)。程序輸出結(jié)果是 Café。

如果我們把 16 進(jìn)制換成對(duì)應(yīng)的 10 進(jìn)制值會(huì)怎么樣呢？上面的程序還能工作嗎？讓我們來試一試：

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)
}

上面程序的輸出結(jié)果也是Café

用 rune 切片構(gòu)造字符串

package main

import (  
    "fmt"
)

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

在上面的程序中 runeSlice 包含字符串 Se?or的 16 進(jìn)制的 Unicode 代碼點(diǎn)。這個(gè)程序?qū)?huì)輸出Se?or。

字符串的長(zhǎng)度

[utf8 package] 包中的 func RuneCountInString(s string) (n int) 方法用來獲取字符串的長(zhǎng)度。這個(gè)方法傳入一個(gè)字符串參數(shù)然后返回字符串中的 rune 的數(shù)量。

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)
}

上面程序的輸出結(jié)果是：

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

字符串是不可變的

Go 中的字符串是不可變的。一旦一個(gè)字符串被創(chuàng)建，那么它將無法被修改。

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 行，我們?cè)噲D把這個(gè)字符串中的第一個(gè)字符修改為 'a'。由于字符串是不可變的，因此這個(gè)操作是非法的。所以程序拋出了一個(gè)錯(cuò)誤 main.go:8: cannot assign to s[0]。

為了修改字符串，可以把字符串轉(zhuǎn)化為一個(gè) rune 切片。然后這個(gè)切片可以進(jìn)行任何想要的改變，然后再轉(zhuǎn)化為一個(gè)字符串。

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 函數(shù)接收一個(gè) rune 切片參數(shù)，它將切片的第一個(gè)元素修改為 'a'，然后將 rune 切片轉(zhuǎn)化為字符串，并返回該字符串。程序的第 13 行調(diào)用了該函數(shù)。我們把 h 轉(zhuǎn)化為一個(gè) rune 切片，并傳遞給了 mutate。這個(gè)程序輸出 aello。

字符串的操作

func main() {
    fmt.Println("字符串測(cè)試")

    fmt.Println("字符串轉(zhuǎn)化")
    //獲取程序運(yùn)行的操作系統(tǒng)平臺(tái)下 int 類型所占的位數(shù)，如：strconv.IntSize。
    //strconv.IntSize

    fmt.Println("將字符串轉(zhuǎn)換為 int 型。")
    var trastr01 string = "100"
    traint01, err_tra := strconv.Atoi(trastr01)
    if err_tra != nil {
        fmt.Println(err_tra)
    } else {
        fmt.Println(traint01)
    }
    fmt.Println("將字符串轉(zhuǎn)換為 float64 型")
    var trastr02 string = "100.55"
    trafloat01, err_float := strconv.ParseFloat(trastr02, 10)
    if err_float != nil {
        fmt.Println(err_float)
    } else {
        fmt.Println(trafloat01)
    }
    trastr03 := strconv.Itoa(99)
    fmt.Println("int 轉(zhuǎn)字符安 " + trastr03)

    var str01 string = "hello,world"
    str02 := "你好,世界"
    fmt.Println(str01)
    fmt.Println(str02)

    //

    //字符串比較
    com01 := strings.Compare(str01, str02)
    if com01 == 0 {
        fmt.Println("相等")
    } else {
        fmt.Println("不相等 " + string(com01))
    }
    fmt.Println(com01)

    //查找 包含
    var isCon bool = strings.Contains(str01, "hello")
    fmt.Println(isCon) //true

    //查找位置
    var theIndex int = strings.Index(str01, ",")
    fmt.Println(theIndex)                     //5
    fmt.Println(strings.Index(str01, "haha")) //不存在返回-1

    lastIndex := strings.LastIndex(str01, "o")
    fmt.Println("在字符串中最后出現(xiàn)位置的索引 " + strconv.Itoa(lastIndex)) //7
    //-1 表示字符串 s 不包含字符串

    //統(tǒng)計(jì)給定子串sep的出現(xiàn)次數(shù), sep為空時(shí), 返回1 + 字符串的長(zhǎng)度
    fmt.Println(strings.Count("cheeseeee", "ee")) // 3
    fmt.Println(strings.Count("five", ""))        // 5

    // 重復(fù)s字符串count次, 最后返回新生成的重復(fù)的字符串
    fmt.Println("hello " + strings.Repeat("world ", 10))

    fmt.Println("替換")
    // 在s字符串中, 把old字符串替換為new字符串，n表示替換的次數(shù)，小于0表示全部替換
    var str03 string = "/Users//Documents/GOPatch/src/MyGO/config/TestString/"
    str04 := strings.Replace(str03, "/", "**", -1)
    str05 := strings.Replace(str03, "/", "**", 4)

    fmt.Println(str04) //**Users****Documents**GOPatch**src**MyGO**config**TestString**
    fmt.Println(str05) //**Users****Documents**GOPatch/src/MyGO/config/TestString/

    fmt.Println("刪除字符串的開頭和尾部")
    fmt.Println("刪除兩頭的/ = " + strings.Trim(str03, "/"))      //Users//Documents/GOPatch/src/MyGO/config/TestString
    fmt.Println("刪除左邊的/ =  " + strings.TrimLeft(str03, "/")) //Users//Documents/GOPatch/src/MyGO/config/TestString/
    //還有 TrimRight

    str06 := strings.TrimSpace(" hello hao hao hao ")
    fmt.Println("刪除開頭末尾的空格 =" + str06) //'hello hao hao hao'

    fmt.Println("大小寫")
    str07 := "hello hao hao hao"
    fmt.Println(strings.Title(str07))                  //Hello Hao Hao Hao
    fmt.Println(strings.ToLower(" Hello Hao Hao Hao")) // hello hao hao hao
    fmt.Println(strings.ToUpper(str07))                //HELLO HAO HAO HAO

    //前綴 后綴
    fmt.Println(strings.HasPrefix("Gopher", "Go")) // true
    fmt.Println(strings.HasSuffix("Amigo", "go"))  // true

    fmt.Println("字符串分割")
    fieldsStr := "  hello   it's  a  nice day today    "
    //根據(jù)空白符分割,不限定中間間隔幾個(gè)空白符
    fieldsSlece := strings.Fields(fieldsStr)
    fmt.Println(fieldsSlece) //[hello it's a nice day today]

    for i, v := range fieldsSlece {
        fmt.Printf("下標(biāo) %d 對(duì)應(yīng)值 = %s \n", i, v)
    }
    for i := 0; i < len(fieldsSlece); i++ {
        fmt.Println(fieldsSlece[i])
    }

    //根據(jù)特定字符分割
    slice01 := strings.Split("q,w,e,r,t,y,", ",")
    fmt.Println(slice01)      //[q w e r t y ]
    fmt.Println(cap(slice01)) //7  最后多個(gè)空""
    for i, v := range slice01 {
        fmt.Printf("下標(biāo) %d 對(duì)應(yīng)值 = %s \n", i, v)
    }

    //拼接
    //Join 用于將元素類型為 string 的 slice, 使用分割符號(hào)來拼接組成一個(gè)字符串：
    var str08 string = strings.Join(fieldsSlece, ",")
    fmt.Println("Join拼接結(jié)果=" + str08) //hello,it's,a,nice,day,today

    fmt.Println("------------對(duì)比字符串拼接效率----------------")
    var buffer bytes.Buffer

    start := time.Now()
    for i := 0; i < 100000; i++ {
        buffer.WriteString("test is here\n")
    }
    buffer.String() // 拼接結(jié)果
    end := time.Now()
    fmt.Println("Buffer time is ", end.Sub(start).Seconds())

    start = time.Now()
    str := ""
    for i := 0; i < 100000; i++ {
        str += "test is here\n"
    }
    end = time.Now()
    fmt.Println("+= time is ", end.Sub(start).Seconds())

    start = time.Now()
    var sl []string
    for i := 0; i < 100000; i++ {
        sl = append(sl, "test is here\n")
    }
    strings.Join(sl, "")
    end = time.Now()
    fmt.Println("Join time is", end.Sub(start).Seconds())
    /*
        Buffer time is  0.00388283
        += time is  11.730007558
        Join time is 0.016644653
    */

}