golang教程之String

String

原文：https://golangbot.com/strings/

字符串在Go中值得学习，因为与其他语言相比，它们在实现方面有所不同。

什么是String？

Go中的字符串是一个字节片。 可以通过将其内容封闭在“”内来创建字符串。 让我们看一个简单的例子，它创建一个字符串并打印它。

package main

import (  
    "fmt"
)

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

上面的程序将输出Hello World。

Go中的String符合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循环以十六进制表示法打印这些字节。 ％x是十六进制的格式说明符。 上述程序输出48 65 6c 6c 6f 20 57 6f 72 6c 64.这些是“Hello World”的Unicode UT8编码值。 需要对Unicode和UTF-8有基本的了解才能更好地理解字符串。 我建议阅读https://naveenr.net/unicode-character-set-and-utf-8-utf-16-utf-32-encoding/以了解什么是Unicode和UTF-8。

让我们稍微修改上面的程序来打印字符串的字符。

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  

虽然上面的程序看起来像是访问字符串的各个字符的合法方式，但这有一个严重的错误。 让我们调试这段代码，看看我们做错了什么。

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的字符并输出错误的Seño r。 为什么这个程序会破坏Señor，当它与Hello World完全没问题时。 原因是ñ的Unicode代码点是U+00F1，其UTF-8编码占用2个字节c3和b1。 我们正在尝试打印字符，假设每个代码点都是一个字节长，这是错误的。 在UTF-8编码中，代码点可以占用超过1个字节。 那么我们如何解决这个问题呢。 这就是rune拯救我们的地方。

rune

rune是Go中的内置类型，它是int32的别名。 rune表示Go中的Unicode代码点。 代码点占用的字节数无关紧要，它可以用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

上述程序是迭代各个rune字符串的完美方式。但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行中，使用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  

从上面的输出中可以清楚地看到ñ - 占用2个字节。

从字节切片构造字符串

package main

import (  
    "fmt"
)

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

上面程序中的byteSlice包含字符串“Café”的UTF-8编码十六进制字节。 该程序输出了Café。

如果我们有十六进制值的十进制等值，该怎么办 上述计划是否有效？ 让我们来看看。

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é。

从runes切片构造一个字符串

package main

import (  
    "fmt"
)

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

在上面的程序中，runeSlice包含十六进制字符串Señor的Unicode代码点。 该程序输出Señor。

字符串的长度

utf8包提供func RuneCountInString（s string）（n int）函数用于查找字符串的长度。 此方法将字符串作为参数，并返回其中的runes数。

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]

要解决此字符串不变性，字符串将转换为runes切片。 然后，该片段随着所需的任何更改而更改，并转换回新的字符串。

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’，在第13行调用此方法，将符文转换回字符串并返回它。h被转换为rune切片并传递给mutate。 该程序输出aello

我在github中创建了一个程序，其中包含我们讨论的所有内容。 您可以在这里 下载。