@ -2,16 +2,16 @@
14 - 字符串
14 - 字符串
========================
========================
上一节：[第十三篇 Map](/docs/golang_tutorial_13 .md)
上一节：[第十篇 if else 语句](/docs/golang_tutorial_10 .md)
下一节：[第十五篇 指针](/docs/golang_tutorial_15 .md)
下一节：[第十二篇 包](/docs/golang_tutorial_12 .md)
这是本Golang系列教程的第14篇。
这是本Golang系列教程的第14篇。
` ` 类型单独提取为一篇教程是因为在 Go 中，` string` 的实现方式同其他语言的不同。 string 类型单独提取为一篇教程是因为在 Go 中，
## 访问字符串中的字节
## 什么是字符串？
因为字符串是字节数组，因此可以访问一个字符串中的字节。 在 Go 中字符串是 byte 数组。可以通过将内容放在双引号 "" 之间的方式来创建一个字符串。让我们看一个简单的例子，该例子创建并打印一个字符串：
```golang
```golang
package main
package main
@ -20,23 +20,26 @@ import (
"fmt"
"fmt"
)
)
// 打印字符串中的字节
func printBytes(s string) {
for i := 0; i < len ( s ) ; i + + {
fmt.Printf("%x ", s[i])
}
}
func main() {
func main() {
name := "Hello World"
name := "Hello World"
printBytes (name) fmt.Println(name)
}
}
```
```
在上面的程序中，`len(s)` 返回字符串中的字节数，我们用一个 `for` 循环以 16 进制打印这些字节。`%x` 格式化指示符用来以 16 进制打印参数。上面的程序打印：`48 65 6c 6c 6f 20 57 6f 72 6c 64`。它们是 `"Hello World"` 以 `UTF-8` 方式编码的 `Unicode` 值。对 `Unicode` 字符集和 `UTF-8` 编码有一个基本的了解会更好的理解 `string` 类型。我（ ） ： `Unicode` 和 `UTF-8` 。
上面输出：`Hello World`。
Go 中的字符串符合 Unicode 标准，并以 UTF-8 编码。
## 如何创建 map？
可以通过将键和值的类型传递给内置函数 `make` 来创建一个 `map` 。语法为：`make(map[KeyType]ValueType)`。（译者注：`map` 的类型表示为 `map[KeyType]ValueType` ）例如：
```golang
personSalary := make(map[string]int)
```
## 访问字符串中的字符
上面的代码创建了一个名为 `personSalary` 的 map。其中键的类型为 string，
让我们修改上面的程序以打印字符串中的字符：
**map 的 0 值为 `nil` 。试图给一个 nil map 添加元素给会导致运行时错误。因此 map 必须通过 make 来初始化** （译者注：也可以使用速记声明来创建 map， ）
```golang
```golang
package main
package main
@ -45,35 +48,39 @@ import (
"fmt"
"fmt"
)
)
func printBytes(s string) {
func main() {
for i:= 0; i < len ( s ) ; i + + {
var personSalary map[string]int
fmt.Printf("%x ", s[i])
if personSalary == nil {
fmt.Println("map is nil. Going to make one.")
personSalary = make(map[string]int)
}
}
}
}
```
上面的程序中，`personSalary` 为 `nil` ，因此使用 make 初始化它。程序的输出为：`map is nil. Going to make one`.
func printChars(s string) {
## 向 map 中插入元素
for i:= 0; i < len ( s ) ; i + + {
fmt.Printf("%c ",s[i])
插入元素给 map 的语法与数组相似。下面的代码插入一些新的元素给 `map personSalary` 。
}
```golang
}
package main
import (
"fmt"
)
func main() {
func main() {
name := "Hello World"
personSalary := make(map[string]int)
printBytes(name)
personSalary["steve"] = 12000
fmt.Printf("\n")
personSalary["jamie"] = 15000
printChars(name)
personSalary["mike"] = 9000
fmt.Println("personSalary map contents:", personSalary)
}
}
```
```
在第 16 行的 `printChars` 函数中，`%c` 格式化指示符用来打印字符串中的字符。上面的程序输出为：
上面的程序输出：`personSalary map contents: map[steve:12000 jamie:15000 mike:9000]`。
```golang
48 65 6c 6c 6f 20 57 6f 72 6c 64
Hello World
```
虽然上面的程序看起来是一种合法的打印字符串中各个字符的方法，但是这里有一个严重的错误。让我们深入这段代码看看究竟是哪里不对。 也可以在声明时初始化一个数组：
```golang
```golang
package main
package main
@ -82,45 +89,27 @@ import (
"fmt"
"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() {
func main() {
name := "Hello World"
personSalary := map[string]int {
printBytes(name)
"steve": 12000,
fmt.Printf("\n")
"jamie": 15000,
printChars(name)
}
fmt.Printf("\n")
personSalary["mike"] = 9000
name = "Señor"
fmt.Println("personSalary map contents:", personSalary)
printBytes(name)
fmt.Printf("\n")
printChars(name)
}
}
```
```
上面程序的输出为：
上面的程序在声明 personSalary 的同时向其中插入了两个元素。接着插入了一个以 "mike" 为键的元素。程序的输出为：
```golang
```golang
48 65 6c 6c 6f 20 57 6f 72 6c 64
personSalary map contents: map[steve:12000 jamie:15000 mike:9000]
Hello World
53 65 c3 b1 6f 72
Señor
```
```
我们尝试将 `"Señor"` 中的每个字符打印出来，但是却得到了 `"Señor"` 。为什么这个程序在 `"Hello World"` 上运行正常，但是不适用于 `"Señor"` 呢？因为 `ñ` 的 `Unicode` 码点是 `U+00F1` ，因而它的 `UTF-8` 编码占了两个字节：`c3` 和 `b1` 。上面的程序假定每个码点只有一个字节长度，因此会发生错误。**在 `UTF-8` 编码中，一个码点可能会占一个以上的字节。**在这种情况下，我们需要 `rune` 来帮助解决问题。 `string` 并不是可以作为键的唯一类型， ， ， ， ， ， ， ：
## rune
## 访问 map 中的元素
`rune` 是 Go 中的内置类型，它是 `int32` 的别名。在 Go 中，`rune` 表示一个 `Unicode` 码点。无论一个码点会被编码为多少个字节，它都可以表示为一个 `rune` 。让我们修改上面的程序，使用 `rune` 来打印字符串中的字符。现在我们已经添加了一些元素给 map，
```golang
```golang
package main
package main
@ -129,46 +118,56 @@ import (
"fmt"
"fmt"
)
)
func printBytes(s string) {
func main() {
for i:= 0; i < len ( s ) ; i + + {
personSalary := map[string]int{
fmt.Printf("%x ", s[i])
"steve": 12000,
"jamie": 15000,
}
}
personSalary["mike"] = 9000
employee := "jamie"
fmt.Println("Salary of", employee, "is", personSalary[employee])
}
}
```
func printChars(s string) {
上面的程序非常简单。员工 `jamie` 的工资被取出并打印。程序的输出为：`Salary of jamie is 15000`。
runes := []rune(s)
for i:= 0; i < len ( runes ) ; i + + {
如果一个键不存在会发生什么？`map` 会返回值类型的 `0 ` 值。比如如果访问了 `personSalary` 中的不存在的键，那么将返回 `int` 的 0 值，也就是 0。
fmt.Printf("%c ",runes[i])
}
```golang
}
package main
import (
"fmt"
)
func main() {
func main() {
name := "Hello World"
personSalary := map[string]int{
printBytes(name)
"steve": 12000,
fmt.Printf("\n")
"jamie": 15000,
printChars(name)
}
fmt.Printf("\n\n")
personSalary["mike"] = 9000
name = "Señor"
employee := "jamie"
printBytes(name)
fmt.Println("Salary of", employee, "is", personSalary[employee])
fmt.Printf("\n")
fmt.Println("Salary of joe is", personSalary["joe"])
printChars(name)
}
}
```
```
在上面的程序中，第 14 行，字符串被转换为 `rune` 切片。然后我们遍历该切片并打印其中的字符。程序的输出如下： 上面的程序输出为:
```golang
```golang
48 65 6c 6c 6f 20 57 6f 72 6c 64
Salary of jamie is 15000
Hello World
Salary of joe is 0
53 65 c3 b1 6f 72
Señor
```
```
上面的输出是正确的，这正是我们想要的结果。
上面的程序返回 `joe` 的工资为` 0`。我们没有得到任何运行时错误说明键 joe 在 `personSalary` 中不存在。
## 使用 for range 遍历字符串 我们如何检测一个键是否存在于一个 map 中呢？可以使用下面的语法：
上面的程序是遍历字符串中字符的一个正确方式。但是 Go 提供了一种更简单的方式来做到这一点：使用 `for range` 循环。
```golang
value, ok := map[key]
```
上面的语法可以检测一个特定的键是否存在于 map 中。如果 `ok` 是 `true` ， ， `ok` 为 `false` ，则表示键不存在。
```golang
```golang
package main
package main
@ -177,31 +176,30 @@ import (
"fmt"
"fmt"
)
)
func printCharsAndBytes(s string) {
func main() {
for index, rune := range s {
personSalary := map[string]int{
fmt.Printf("%c starts at byte %d\n", rune, index)
"steve": 12000,
"jamie": 15000,
}
personSalary["mike"] = 9000
newEmp := "joe"
value, ok := personSalary[newEmp]
if ok == true {
fmt.Println("Salary of", newEmp, "is", value)
} else {
fmt.Println(newEmp,"not found")
}
}
}
func main() {
name := "Señor"
printCharsAndBytes(name)
}
}
```
```
在上面的程序中，第 8 行通过使用 `for range` 循环遍历字符串。该循环返回一个 `rune` （在 `byte` 数组中）的位置，以及 `rune` 本身。上面的程序输出为：
在上面的程序中，第 15 行，`ok` 应该为 `false` ，因为 `joe` 不存在。因此程序的输出为：
```golang
```golang
S starts at byte 0
joe not found
e starts at byte 1
ñ starts at byte 2
o starts at byte 4
r starts at byte 5
```
```
从上面的输出可以看到，ñ 占两个字节 :)
range for 可用于遍历 map 中所有的元素（译者注：这里 range 操作符会返回 map 的键和值）。
## 通过 `byte` 切片创建字符串
```golang
```golang
package main
package main
@ -211,15 +209,32 @@ import (
)
)
func main() {
func main() {
byteSlice := []byte{0x43, 0x61, 0x66, 0xC3, 0xA9}
personSalary := map[string]int{
str := string(byteSlice)
"steve": 12000,
fmt.Println(str)
"jamie": 15000,
}
personSalary["mike"] = 9000
fmt.Println("All items of a map")
for key, value := range personSalary {
fmt.Printf("personSalary[%s] = %d\n", key, value)
}
}
}
```
```
在上面的程序中，`byteSlice` 是 `"Café"` 经过 `UTF-8` 编码后得到的切片（用 16 进制表示） 。上面的程序输出为：`Café`。
上面的程序输出如下：
```golang
All items of a map
personSalary[mike] = 9000
personSalary[steve] = 12000
personSalary[jamie] = 15000
```
值得注意的是，因为 map 是无序的，因此对于程序的每次执行，不能保证使用 range for 遍历 map 的顺序总是一致的。
如果我们换成对应的十进制数程序会正常工作吗？答案是：`Yes`。让我们测试一下：
## 删除元素
`delete(map, key) ` 用于删除 map 中的 key。delete 函数没有返回值。
```golang
```golang
package main
package main
@ -229,15 +244,28 @@ import (
)
)
func main() {
func main() {
byteSlice := []byte{67, 97, 102, 195, 169} //decimal equivalent of {'\x43', '\x61', '\x66', '\xC3', '\xA9'}
personSalary := map[string]int{
str := string(byteSlice)
"steve": 12000,
fmt.Println(str)
"jamie": 15000,
}
personSalary["mike"] = 9000
fmt.Println("map before deletion", personSalary)
delete(personSalary, "steve")
fmt.Println("map after deletion", personSalary)
}
}
```
```
上面的程序同样输出：`Café`。
上面的程序删除以 `steve` 为键的元素。程序输出为：
```golang
map before deletion map[steve:12000 jamie:15000 mike:9000]
map after deletion map[mike:9000 jamie:15000]
```
## map 的大小
## 通过 `rune` 切片创建字符串
用内置函数 `len` 获取 map 的大小：
```golang
```golang
package main
package main
@ -247,89 +275,164 @@ import (
)
)
func main() {
func main() {
runeSlice := []rune{0x0053, 0x0065, 0x00f1, 0x006f, 0x0072}
personSalary := map[string]int{
str := string(runeSlice)
"steve": 12000,
fmt.Println(str)
"jamie": 15000,
}
personSalary["mike"] = 9000
fmt.Println("length is", len(personSalary))
}
}
```
```
在上面的程序中，`runeSlice` 包含了字符串 `"Señor"` 的 `Unicode` 码点（以 16 进制表示）。程序的输出为：`Señor`。
上面程序中，`len(personSalary) `获取 ` personSalary` 的大小。上面的程序输出：`length is 3 `。
## 字符串的长度
## map 是引用类型
utf8 包 提供了 `func RuneCountInString(s string) (n int)` 来获取字符串的长度，该方法接受一个字符串作为参数，并返回该字符串中 `rune` 的数量。
与切片一样，
（译者注：`RuneCountInString` 返回字符串中 `Unicode` 字符的个数，而 `len` 返回字符串中 `byte` 的个数。因此用 `len` 来获取字符串长度可能会导致错误。）
```golang
```golang
package main
package main
import (
import (
"fmt"
"fmt"
"unicode/utf8"
)
)
func length(s string) {
fmt.Printf("length of %s is %d\n", s, utf8.RuneCountInString(s))
}
func main() {
func main() {
personSalary := map[string]int{
word1 := "Señor"
"steve": 12000,
length(word1)
"jamie": 15000,
word2 := "Pets"
}
length(word2)
personSalary["mike"] = 9000
fmt.Println("Original person salary", personSalary)
newPersonSalary := personSalary
newPersonSalary["mike"] = 18000
fmt.Println("Person salary changed", personSalary)
}
}
```
```
上面程序的输出为：
上面的程序中，第 14 行，`personSalary` 赋值给 `newPersonSalary` 。下一行，将 `newPersonSalary` 中 `mike` 的工资改为 `18000` 。那么在 `personSalary` 中 `mike` 的工资也将变为 `18000` 。程序的输出如下 ：
```golang
```golang
length of Señor is 5 Original person salary map[steve:12000 jamie:15000 mike:9000]
length of Pets is 4 Person salary changed map[jamie:15000 mike:18000 steve:12000]
```
```
## 字符串是不可变的
将 map 作为参数传递给函数也是一样的。在函数中对 map 的任何修改都会影响在调用函数中看到。
## 比较 map
在 Go 中字符串是不可变的。字符串一旦被创建就无法改变。
map 不能通过 `== ` 操作符比较是否相等。`== `操作符只能用来检测 map 是否为 nil 。
```golang
```golang
package main
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() {
func main() {
h := "hello"
map1 := map[string]int{
fmt.Println(mutate(h))
"one": 1,
"two": 2,
}
map2 := map1
if map1 == map2 {
}
}
}
```
```
上面的程序中，第 8 行我们试图改变字符串的第一个字符为 `a` 。任何在单引号内的 `Unicode` 字符都是 `rune` 。由于字符串是不可变的，因此这是非法的，将会报错：`main.go:8: cannot assign to s[0]`。
上面的程序将会报错：`invalid operation: map1 == map2 (map can only be compared to nil)`。
比较两个 map 是否相等的方式是一一比较它们的元素是否相等。我会鼓励你为此编写一个程序，使其工作：）
**为了改变一个字符串中的字符，我们需要先把字符串转换为 `rune` 切片，然后修改切片中的内容，最后将这个切片转换回字符串**。
我（原文作者）已经将我们讨论的所有概念汇总到一个程序中，你可以从 [github ](https://github.com/golangbot/arraysandslices ) 下载。
## 知识扩展
[Go编程基础视频教程笔记 ](https://study.163.com/course/courseLearn.htm?courseId=306002#/learn/video?lessonId=421019&courseId=306002 )
```golang
```golang
package main
package main
import (
import (
"fmt"
"fmt"
"sort"
)
)
func mutate(s []rune) string {
func main(){
s[0] = 'a'
// 方式一
return string(s)
var m map[int]string // 声明一个map
}
fmt.Println(m)
func main() {
m = map[int]string{} // 初始化一个map
h := "hello"
fmt.Println(m)
fmt.Println(mutate([]rune(h)))
// 方式二
var m2 map[int]string = map[int]string{}
fmt.Println(m2)
// 方式三
m3 := map[int]string{}
fmt.Println(m3)
// 设置、获取、删除
m3[1] = "Tinywan"
a := m3[1]
fmt.Println(m3) // map[1:Tinywan]
fmt.Println(a) // Tinywan
delete(m3,1) // 删除一个map
fmt.Println(m3) // map[]
// 复杂map 的操作
var m5 map[int]map[int]string // 定义
m5 = make(map[int]map[int]string) // 通过 make 初始化 最外层的 map
m5[1] = make(map[int]string) // 针对外层value 的map进行初始化
m5[1][1] = "OK"
m_a := m5[1][1] // 取出map 的值赋予一个变量
fmt.Println(m_a) // OK
// 判断一个map 有没有被初始化，使用多返回值判断
m_b, ok := m5[2][1]
// 判断是否被初始化操作
if !ok {
m5[2] = make(map[int]string)
}
m5[2][1] = "OK b"
m_b,ok = m5[2][1]
fmt.Println(m_b, ok) // OK b true
// 迭代操作
s_map := make([]map[int]string,5) // 以 map 为元素的slice 使用 make 创建一个切片,元素的slic
for _,v := range s_map {
v = make(map[int]string) // v 是值的拷贝
v[1] = "OK"
fmt.Println(v);
}
fmt.Println(s_map)
// 针对一个 map 直接操作
for i := range s_map {
s_map[i] = make(map[int]string)
s_map[i][1] = "OK"
fmt.Println(s_map[i]);
}
fmt.Println(s_map)
// map 的间接排序
// map 集合
map01 := map[int]string{1:"a", 2:"b", 3:"n", 4:"c", 5:"p", 6:"f"}
// 切片
slice01 := make([]int, len(map01))
i := 0
for k, _ := range map01 {
slice01[i] = k
i++
}
fmt.Println(slice01) // 返回的是一个无序的数组:[5 6 1 2 3 4] [3 4 5 6 1 2]
sort.Ints(slice01)
fmt.Println(slice01) // 有序的数组:[1 2 3 4 5 6]
}
}
```
```
在上面的程序中，第 7 行 `mutate` 函数接收一个 `rune` 切片作为参数。然后将该切片的第一个元素改为 `a` ，最后再转换回字符串并返回。该函数在程序中的第 13 行被调用。`h` 被转换为一个 `rune` 切片传递给 `mutate` 。程序的输出为：`aello`。
希望你喜欢阅读。请留下宝贵的意见和反馈:)
字符串的介绍到此为止。感谢阅读。
ShaoBo Wan(无极)
