Go 系列教程 —— 14. 字符串

欢迎阅读 Golang 系列教程第 14 部分。

由于和其他语言相比,字符串在 Go 语言中有着自己特殊的实现,因此在这里需要被特别提出来。

什么是字符串?

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。这些打印出来的字符是 "Hello World" 以 Unicode UTF-8 编码的结果。为了更好的理解 go 中的字符串,需要对 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

上面的程序获取字符串的每一个字符,虽然看起来是合法的,但却有一个严重的 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

 

 

字符串常用API

1.字符串切割函数Split,分割完成后是一个数组

    sRecv="0=hq|1=HSIML|2=111111"

a1 := strings.Split(sRecv, "|")

返回结果 a1 是一个数组 可通过
a1[1]  这样的方式进行调用



2.判断是否包含某个字符串

判断子字符串或字符在父字符串中出现的位置(索引)


(1)方法1         Index 返回字符串 str 在字符串 s 中的索引( str 的第一个字符的索引),-1 表示字符串 s 不包含字符串 str :

                strings.Index(s, str string) int


(2)方法2       LastIndex 返回字符串 str 在字符串 s 中最后出现位置的索引( str 的第一个字符的索引),-1 表示字符串 s 不包含字符串 str :

       strings.LastIndex(s, str string) int


(3)如果 ch 是非 ASCII 编码的字符,建议使用以下函数来对字符进行定位:
      strings.IndexRune(s string, ch int) int

 

3.字符串转化

(1) go string []byte相互转换

string 不能直接和byte数组转换

string可以和byte的切片转换

1,string 转为[]byte

var str string = "test"

var data []byte = []byte(str)

 

2,byte转为string

var data [10]byte 

byte[0] = 'T'

byte[1] = 'E'

var str string = string(data[:])

 

 

字符串操作完整的例子

 

 

func main2401() {
// 1.Contains查找
/* str := "hello world"
value := strings.Contains(str, "llo") // true
if value {
fmt.Println("出现")
} else {
fmt.Println("未出现")
} */

// 2.Join拼接
/* s := []string{"13", "dsf"}
value := strings.Join(s, " ") // 13 dsf
*/

// 3.Index查找位置
// str := "你好,在吗"
// // 1个汉字是3个字符
// value := strings.Index(str, "好") // 3

// 4.Repeat 重复
// str := "你好,你好呀"
// value := strings.Repeat(str, 2) // 你好,你好呀你好,你好呀

// 5.Replace 替换
// str := "hello world"
// // -1表示全部替换
// value := strings.Replace(str, "l", "2", -1) // he22o world

// 6.Split 分割成切片
// str := "www.it.com"
// value := strings.Split(str, ".")

// 7. Trim 删除两边的字符串
// str := "===www.==it.com=="
// value := strings.Trim(str, "=")

// 8.Fields 去掉字符串中的空格,并返回切片
// str := " www. it.com "
// value := strings.Fields(str)

// 9.Format,吧其他类型转化成字符串
// 将bool类型转化成字符串
// value := strconv.FormatBool(false)
// 将整型转化成字符串
// value := strconv.FormatInt(123, 10)

// 10.Parse将字符串转化成其他类型
// 字符串的true转化成true,其他多东西都会失败
// str := "false"
// value, err := strconv.ParseBool(str)
// if err != nil {
// fmt.Println(err)
// } else {
// fmt.Println(value)
// }

// 将字符串转化成整型
// str := "123"
// value, _ := strconv.ParseInt(str, 10, 12)
// fmt.Println(value)

// 11.Append追加
b := make([]byte, 0, 1024)
value := strconv.AppendBool(b, false)
value = strconv.AppendInt(value, 123, 10)
value = strconv.AppendQuote(value, "hello")
fmt.Println(string(value))

}
posted @ 2019-08-14 09:01  风一样自由419154  阅读(417)  评论(0编辑  收藏  举报