From 86cea0734146849dc57a9d85785e3c90909bddd2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?ShaoBo=20Wan=28=E7=84=A1=E5=B0=98=29?= <756684177@qq.com> Date: Sun, 30 Aug 2020 21:19:44 +0800 Subject: [PATCH] =?UTF-8?q?Revert=20"=E4=BF=AE=E6=94=B9013=20014=20015=200?= =?UTF-8?q?16=20(#17)"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit cc5a5b9e32ad12b9e2d34c636e0172213143eea7. --- docs/golang_tutorial_13.md | 4 +- docs/golang_tutorial_14.md | 2 +- docs/golang_tutorial_15.md | 388 ++++++++++++++++++-------- docs/golang_tutorial_16.md | 541 ++++++++++++++++++------------------- 4 files changed, 530 insertions(+), 405 deletions(-) diff --git a/docs/golang_tutorial_13.md b/docs/golang_tutorial_13.md index a89974c..2164051 100644 --- a/docs/golang_tutorial_13.md +++ b/docs/golang_tutorial_13.md @@ -251,7 +251,7 @@ map after deletion map[mike:9000 jamie:15000] ## 结构体 map （Map of Structs） -目前我们编写了存储员工工资的 map，那么可否将员工的国籍也存储在 map 中呢？这可以通过结构体 map 来完成。每个员工可以用一个包含了 `salary` 和 `country` 字段的结构体来表示，这些结构体将被存储在一个键为 `string` 类型，值为 `struct` 类型的 map 中。 +目前我们编写了存储员工工资的 map，那么可否将员工的国籍也存储在 map 中呢？这可以通过结构体 map 来完成。每个员工可以用一个包含了“工资”和“国籍”的结构体来表示，这些结构体将被存储在一个键为 `string` 类型，值为 `struct` 类型的 map 中。 ```golang package main @@ -291,7 +291,7 @@ func main() { } ``` -以上程序中，`employee` 结构体包含了 `salary` 和 `country` 两个字段。 +以上程序中，`employee` 结构体包含了 `salary` 和 `country`。 在第25行，我们创建了一个 map，键为字符串类型，值为 `employee` 结构体，并添加了我们创建的三个员工。 diff --git a/docs/golang_tutorial_14.md b/docs/golang_tutorial_14.md index c8662c3..34c809d 100644 --- a/docs/golang_tutorial_14.md +++ b/docs/golang_tutorial_14.md @@ -116,7 +116,7 @@ Hello World Señor ``` -我们尝试将 `"Señor"` 中的每个字符打印出来，但是却得到了 `"Señor"`。为什么这个程序在 `"Hello World"` 上运行正常，但是不适用于 `"Señor"` 呢？因为 `ñ` 的 `Unicode` 码点是 `U+00F1`，因而它的 `UTF-8` 编码占了两个字节：`c3` 和 `b1`。上面的程序假定每个码点只有一个字节长度，因此会发生错误。**在 `UTF-8` 编码中，一个码点可能会占一个以上的字节。** 在这种情况下，我们需要 `rune` 来帮助解决问题。 +我们尝试将 `"Señor"` 中的每个字符打印出来，但是却得到了 `"Señor"`。为什么这个程序在 `"Hello World"` 上运行正常，但是不适用于 `"Señor"` 呢？因为 `ñ` 的 `Unicode` 码点是 `U+00F1`，因而它的 `UTF-8` 编码占了两个字节：`c3` 和 `b1`。上面的程序假定每个码点只有一个字节长度，因此会发生错误。**在 `UTF-8` 编码中，一个码点可能会占一个以上的字节。**在这种情况下，我们需要 `rune` 来帮助解决问题。 ## rune diff --git a/docs/golang_tutorial_15.md b/docs/golang_tutorial_15.md index 730a16e..e989435 100644 --- a/docs/golang_tutorial_15.md +++ b/docs/golang_tutorial_15.md @@ -2,10 +2,10 @@ 15 - 指针 ======================== -上一节：[第十四篇 字符串](/docs/golang_tutorial_14.md) -下一节：[第十六篇 结构体](/docs/golang_tutorial_16.md) +上一节：[第十篇 if else 语句](/docs/golang_tutorial_10.md) +下一节：[第十二篇 包](/docs/golang_tutorial_12.md) -这是本Golang系列教程的第15篇。我们将学习 Go 语言中指针的作用，并且将 Go 指针与其他语言（如 C/C++）的指针进行区分。 +这是本Golang系列教程的第15篇。 ## 什么是指针？ @@ -13,14 +13,13 @@ ![pointer-explained](../images/pointer-explained.png) -在上图中，变量 `b` 的值是 `156`，存储在地址为 `0x1040a124` 的内存中。变量 `a` 存储了变量 `b` 的地址，也可以说 `a` 指向 `b`。 +在上图中，变量 `b` 的值是 `156`，存储在地址为 `0x1040a124` 的内存中。变量 `a` 存储了变量 `b` 的地址。现在可以说 `a` 指向 `b`。 ## 指针的声明 指向类型 `T` 的指针用 `*T` 表示。 -让我们写一些代码。 - +让我们写一些代码。 ```golang package main @@ -36,18 +35,25 @@ func main() { } ``` -`&` 操作符用来获取一个变量的地址。在上面的程序中，第 9 行我们将 `b` 的地址赋给 `a`（`a` 的类型为 `*int`）。现在我们说 `a` 指向了 `b`。当我们打印 `a` 的值时，`b` 的地址将会被打印出来。程序的输出为： - +`&` 操作符用来获取一个变量的地址。在上面的程序中，第 9 行我们将 `b` 的地址赋给 `a`（`a` 的类型为 `*int`）。现在我们说 `a` 指向了 `b`。当我们打印 `a` 的值时，`b` 的地址将会被打印出来。程序的输出为： ``` -Type of a is *int -address of b is 0x1040a124 +Type of a is *int +address of b is 0x1040a124 ``` -你可能得到的是一个不同的 `b` 的地址，因为 `b` 可能被存储在内存的任意一个地方。 +你可能得到的是一个不同的 `b` 的地址，因为 `b` 可以在内存中的任何地方。 -## 指针的零值 +## 指针的空值 -指针的零值为 `nil`。 +指针的空值为 `nil` 。 + +```golang +personSalary := make(map[string]int) +``` + +上面的代码创建了一个名为 `personSalary` 的 `map`。其中键的类型为 `string`，值的类型为 `int`。 + +`**map` 的 `0` 值为 `nil`。试图给一个 `nil map` 添加元素给会导致运行时错误。因此 `map` 必须通过 `make` 来初始化（译者注：**也可以使用速记声明来创建 map**，见下文）。 ```golang package main @@ -57,28 +63,38 @@ import ( ) func main() { - a := 25 - var b *int - if b == nil { - fmt.Println("b is", b) - b = &a - fmt.Println("b after initialization is", b) + var personSalary map[string]int + if personSalary == nil { + fmt.Println("map is nil. Going to make one.") + personSalary = make(map[string]int) } } ``` -'b' 首先被初始化为 `nil`，之后被赋值为 `a` 的地址，程序输出为： +上面的程序中，`personSalary` 为 `nil`，因此使用 `make` 初始化它。程序的输出为：`map is nil. Going to make one`. + +## 向 map 中插入元素 +插入元素给 `map` 的语法与数组相似。下面的代码插入一些新的元素给 `map personSalary`。 ```golang -b is -b after initialization is 0x1040a124 -``` +package main -## 利用 `new` 函数创建指针 +import ( + "fmt" +) + +func main() { + personSalary := make(map[string]int) + personSalary["steve"] = 12000 + personSalary["jamie"] = 15000 + personSalary["mike"] = 9000 + fmt.Println("personSalary map contents:", personSalary) +} +``` -Go 还提供一个实用的函数 `new` 来创建指针。`new` 函数接收一个类型，并返回一个该类型的零值指针。 +上面的程序输出：`personSalary map contents: map[steve:12000 jamie:15000 mike:9000]`。 -我们来看一个实例： +也可以在声明时初始化一个数组： ```golang package main @@ -88,48 +104,48 @@ import ( ) func main() { - size := new(int) - fmt.Printf("Size value is %d, type is %T, address is %v\n", *size, size, size) - *size = 85 - fmt.Println("New size value is", *size) + personSalary := map[string]int { + "steve": 12000, + "jamie": 15000, + } + personSalary["mike"] = 9000 + fmt.Println("personSalary map contents:", personSalary) } ``` -上面的程序中，我们在第 8 行利用 `new` 函数创建了一个指向 `int` 类型的指针。由于 `int` 类型的零值为 `0`，变量 `size` 是一个指向 `0` 的整数指针（`*int` 类型）。 - -程序输出： +上面的程序在声明 `personSalary` 的同时向其中插入了两个元素。接着插入了一个以 `"mike"` 为键的元素。程序的输出为： ```golang -Size value is 0, type is *int, address is 0x414020 -New size value is 85 +personSalary map contents: map[steve:12000 jamie:15000 mike:9000] ``` -## 指针的间接引用 +`string` 并不是可以作为键的唯一类型，其他所有可以比较的类型，比如，布尔类型，整型，浮点型，复数类型都可以作为键。如果你想了解更多关于可比较类型的话，请参阅：http://golang.org/ref/spec#Comparison_operators + +## 访问 map 中的元素 -间接引用（dereference）指针就是获取指针所指向的变量的值。间接引用 `a` 的语句是 `*a`。例如： +现在我们已经添加了一些元素给 `map`，现在让我们学习如何从 `map` 中提取它们。根据键获取值的语法为：`map[key]`，例如： ```golang -package main +package main + import ( "fmt" ) func main() { - b := 255 - a := &b - fmt.Println("address of b is", a) - fmt.Println("value of b is", *a) + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, + } + personSalary["mike"] = 9000 + employee := "jamie" + fmt.Println("Salary of", employee, "is", personSalary[employee]) } ``` -在第 10 行，我们间接引用了 `a` 并打印了它的值，也就是 `b` 的值。程序输出为： +上面的程序非常简单。员工 `jamie` 的工资被取出并打印。程序的输出为：`Salary of jamie is 15000`。 -```golang -address of b is 0x1040a124 -value of b is 255 -``` - -我们再编写一个利用指针改变变量 `b` 的值的程序： +如果一个键不存在会发生什么？`map` 会返回值类型的 `0 `值。比如如果访问了 `personSalary` 中的不存在的键，那么将返回 `int` 的 0 值，也就是 0。 ```golang package main @@ -139,24 +155,33 @@ import ( ) func main() { - b := 255 - a := &b - fmt.Println("address of b is", a) - fmt.Println("value of b is", *a) - *a++ - fmt.Println("new value of b is", b) + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, + } + personSalary["mike"] = 9000 + employee := "jamie" + fmt.Println("Salary of", employee, "is", personSalary[employee]) + fmt.Println("Salary of joe is", personSalary["joe"]) } ``` -在第 12 行，我们将 `a` 所指向的值加上了 1，也就是改变了 `b` 的值（因为 `a` 指向 `b`）。因此 `b` 变成了256，程序输出： +上面的程序输出为: ```golang -address of b is 0x1040a124 -value of b is 255 -new value of b is 256 +Salary of jamie is 15000 +Salary of joe is 0 +``` + +上面的程序返回 `joe` 的工资为` 0`。我们没有得到任何运行时错误说明键 `joe` 在 `personSalary` 中不存在。 + +我们如何检测一个键是否存在于一个 `map` 中呢？可以使用下面的语法： + +```golang +value, ok := map[key] ``` -## 将指针传入函数 +上面的语法可以检测一个特定的键是否存在于 `map` 中。如果 `ok` 是 `true`，则键存在，value 被赋值为对应的值。如果 `ok` 为 `false`，则表示键不存在。 ```golang package main @@ -165,28 +190,30 @@ import ( "fmt" ) -func change(val *int) { - *val = 55 -} func main() { - a := 58 - fmt.Println("value of a before function call is",a) - b := &a - change(b) - fmt.Println("value of a after function call is", a) + personSalary := map[string]int{ + "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") + } + } ``` -在第 14 行，我们将存有 `a` 的地址的指针 `b` 传入了 `change` 函数。`change` 函数通过间接引用的方法改变了 `a` 的值，程序输出： +在上面的程序中，第 15 行，`ok` 应该为 `false` ，因为 `joe` 不存在。因此程序的输出为： ```golang -value of a before function call is 58 -value of a after function call is 55 +joe not found ``` -## 从函数中返回指针 - -从函数中返回一个局部变量的指针是完全可以的，Go 语言的编译器会将这个变量分配到堆中。 +`range for` 可用于遍历 `map` 中所有的元素（译者注：这里 `range` 操作符会返回 `map` 的键和值）。 ```golang package main @@ -195,25 +222,33 @@ import ( "fmt" ) -func hello() *int { - i := 5 - return &i -} func main() { - d := hello() - fmt.Println("Value of d", *d) + personSalary := map[string]int{ + "steve": 12000, + "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) + } } ``` -在第 9 行中，我们从 `hello` 函数中返回了局部变量 `i` 的地址。 **该操作在 C/C++ 等语言中是未定义的，因为一旦 `hello` 函数执行“返回”之后，变量 `i` 就不再存在于当前域（scope）内了。但是在 Go 语言中，编译器会进行“逃逸分析”（escape analysis）并且在地址离开当前域时将 `i` 分配到堆中。** 因此这一程序可以运行，输出为： +上面的程序输出如下： ```golang -Value of d 5 +All items of a map +personSalary[mike] = 9000 +personSalary[steve] = 12000 +personSalary[jamie] = 15000 ``` -## 不要将指向数组的指针传入函数中！要用切片 +值得注意的是，因为 `map` 是无序的，因此对于程序的每次执行，不能保证使用 `range for` 遍历 `map` 的顺序总是一致的。 + +## 删除元素 -假设我们想要在一个函数内部对一个数组进行更改，一种实现方法是将一个指向数组的指针传入函数。 +`delete(map, key) `用于删除 `map` 中的 `key`。`delete` 函数没有返回值。 ```golang package main @@ -222,20 +257,29 @@ import ( "fmt" ) -func modify(arr *[3]int) { - (*arr)[0] = 90 -} - func main() { - a := [3]int{89, 90, 91} - modify(&a) - fmt.Println(a) + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, + } + personSalary["mike"] = 9000 + fmt.Println("map before deletion", personSalary) + delete(personSalary, "steve") + fmt.Println("map after deletion", personSalary) + } ``` -在第 13 行，我们将数组 `a` 的地址传入 `modify` 函数。在第 8 行，`modify` 函数内，我们间接引用了 `arr` 并且将数组的第一个元素改为 `90`。这个程序会输出：`[90 90 91]`。 +上面的程序删除以 `steve` 为键的元素。程序输出为： -**a[x] 是 (\*a)[x] 的简写形式，所以上面程序中的 (\*arr)[0] 可以被 arr[0] 代替。** 我们用简写方法重写这个程序： +```golang +map before deletion map[steve:12000 jamie:15000 mike:9000] +map after deletion map[mike:9000 jamie:15000] +``` + +## map 的大小 + +用内置函数 `len` 获取 map 的大小： ```golang package main @@ -244,22 +288,22 @@ import ( "fmt" ) -func modify(arr *[3]int) { - arr[0] = 90 -} - func main() { - a := [3]int{89, 90, 91} - modify(&a) - fmt.Println(a) + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, + } + personSalary["mike"] = 9000 + fmt.Println("length is", len(personSalary)) + } ``` -这个程序也会输出：`[90 90 91]`。 +上面程序中，`len(personSalary) `获取 `personSalary` 的大小。上面的程序输出：`length is 3`。 -**尽管我们可以通过将指向数组的指针传入函数中来对数组进行修改，但是这在 Go 语言中并不是地道的方式，我们应该用切片来解决这类问题。** +## map 是引用类型 -我们用切片来重写之前的程序： +与切片一样，map 是引用类型。当一个 map 赋值给一个新的变量，它们都指向同一个内部数据结构。因此改变其中一个也会反映到另一个： ```golang package main @@ -268,33 +312,141 @@ import ( "fmt" ) -func modify(sls []int) { - sls[0] = 90 -} - func main() { - a := [3]int{89, 90, 91} - modify(a[:]) - fmt.Println(a) + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, + } + personSalary["mike"] = 9000 + fmt.Println("Original person salary", personSalary) + newPersonSalary := personSalary + newPersonSalary["mike"] = 18000 + fmt.Println("Person salary changed", personSalary) } ``` -在第 13 行，我们将一个切片传入了 `modify` 函数，这个函数将切片的第一个元素改为 `90`，程序输出仍然是：`[90 90 91]`。 **因此，不要再把指向数组的指针传入函数了，应该使用的是切片 :)** +上面的程序中，第 14 行，`personSalary` 赋值给 `newPersonSalary`。下一行，将 `newPersonSalary` 中 `mike` 的工资改为 `18000`。那么在 `personSalary` 中 `mike` 的工资也将变为 `18000`。程序的输出如下： -## Go 不支持指针的算术运算 +```golang +Original person salary map[steve:12000 jamie:15000 mike:9000] +Person salary changed map[jamie:15000 mike:18000 steve:12000] +``` + +将 map 作为参数传递给函数也是一样的。在函数中对 map 的任何修改都会影响在调用函数中看到。 -不像 C/C++ 中的指针可以进行算术运算，Go 语言并不支持指针算术运算。 +## 比较 map + +map 不能通过 `== `操作符比较是否相等。`== `操作符只能用来检测 map 是否为 nil。 ```golang package main func main() { - b := [...]int{109, 110, 111} - p := &b - p++ + map1 := map[string]int{ + "one": 1, + "two": 2, + } + + map2 := map1 + + if map1 == map2 { + } } ``` -上面的程序会出现编译错误：`main.go:6: invalid operation: p++ (non-numeric type *[3]int)`。 +上面的程序将会报错：`invalid operation: map1 == map2 (map can only be compared to nil)`。 + +比较两个 map 是否相等的方式是一一比较它们的元素是否相等。我会鼓励你为此编写一个程序，使其工作：） + +我（原文作者）已经将我们讨论的所有概念汇总到一个程序中，你可以从 [github](https://github.com/golangbot/arraysandslices) 下载。 + +## 知识扩展 + +[Go编程基础视频教程笔记](https://study.163.com/course/courseLearn.htm?courseId=306002#/learn/video?lessonId=421019&courseId=306002) + +```golang +package main + +import ( + "fmt" + "sort" +) + +func main(){ + // 方式一 + var m map[int]string // 声明一个map + fmt.Println(m) + m = map[int]string{} // 初始化一个map + fmt.Println(m) + + // 方式二 + 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] +} +``` -我（原文作者）在 [github](https://github.com/golangbot/pointers) 上创建了一个简单的小程序，包含了我们这次所学的全部内容。 +希望你喜欢阅读。请留下宝贵的意见和反馈:) \ No newline at end of file diff --git a/docs/golang_tutorial_16.md b/docs/golang_tutorial_16.md index 6a3894f..fa4d9d1 100644 --- a/docs/golang_tutorial_16.md +++ b/docs/golang_tutorial_16.md @@ -1,16 +1,16 @@ 16 - 结构体 ======================== -上一节：[第十五篇 指针](/docs/golang_tutorial_15.md) -下一节：[第十七篇 方法](/docs/golang_tutorial_17.md) +上一节：[第十篇 if else 语句](/docs/golang_tutorial_10.md) +下一节：[第十二篇 包](/docs/golang_tutorial_12.md) -这是本Golang系列教程的第16篇。 +这是本Golang系列教程的第16篇。 ## 什么是结构体？ 结构体（struct）是用户自定义的类型，它代表若干字段的集合。有些时候将多个数据看做一个整体要比单独使用这些数据更有意义，这种情况下就适合使用结构体。 -比如，我们可以将一个员工的 firstName, lastName 和 age 三个属性打包在一起成为一个 `employee` 结构体。 +比如将一个员工的 firstName, lastName 和 age 三个属性打包在一起成为一个 `employee` 结构就是很有意义的。 ## 结构体的声明 @@ -22,7 +22,7 @@ type Employee struct { } ``` -上面的代码片段声明了一个名为 `Employee` 的结构体类型，它拥有 `firstName`，`lastName` 和 `age` 三个字段。同一类型的多个字段可以合并到一行（用逗号分隔），并将类型放在后面。上面的结构体中 `firstName` 与 `lastName` 都是 `string` 类型，因此可以将它们写在一起。 +上面的代码片段声明了一个名为 `Employee` 的结构体类型，它拥有 firstName，lastName 和 age 三个字段。同一类型的多个字段可以合并到一行（用逗号分隔），并将类型放在后面。上面的结构体中 firstName 与 lastName 都是 string 类型，因此可以将它们写在一起。 ```golang type Employee struct { @@ -31,11 +31,9 @@ type Employee struct { } ``` -*(尽管以上语句节省了代码行数，但是这会导致字段定义不够清晰，请尽量避免使用以上语句的定义方式)* +上面的结构体 `Employee` 是一个**具名结构体`（named structure）`**，因为它创建了一个具有名字的结构体类型： `Employee` 。我们可以定义具名结构体类型的变量。 -上面的结构体 `Employee` 是一个**具名结构体 `（named structs）`** ，因为它创建了一个具有名字的结构体类型：`Employee`。我们可以定义具名结构体类型的变量。 - -我们也可以定义一个没有类型名称的结构体，这种结构体叫做**匿名结构体 `（anonymous structs）`**。 +我们也可以定义一个没有类型名称的结构体，这种结构体叫做**匿名结构体（anonymous structures）**。 ```golang var employee struct { @@ -44,11 +42,11 @@ var employee struct { } ``` -上面的代码片段声明了一个匿名结构体变量 `employee`。 +上面的代码片段声明了一个匿名结构体变量 employee。 ## 定义具名结构体变量 -下面的程序说明了如何定义一个具名结构体 `Employee` 的变量。 +下面的程序说明了如何定义一个具名结构体 Employee 的变量。 ```golang package main @@ -80,9 +78,9 @@ func main() { } ``` -在上面的程序中，我们定义了一个名为 `Employee` 的结构体类型。我们可以通过指定字段的名称和对应的值来创建一个结构体变量，比如在第 15 行，我们就是通过这种方式定义了 `Employee` 类型的一个结构体变量 `emp1`。这里字段名称的顺序没必要和声明结构体类型时的一致。例如这里我们将 `lastName` 放在了最后，程序同样正确运行。 +在上面的程序中，我们定义了一个名为 `Employee` 的结构体类型。我们可以通过指定字段的名称和对应的值来创建一个结构体变量，比如在第15行，我们就是通过这种方式定义了 `Employee` 类型的一个结构体变量 `empl`。这里字段名称的顺序没必要和声明结构体类型时的一致。例如这里我们将 `lastName` 放在了最后，程序同样正确运行。 -在定义结构体变量时也可以忽略字段名称，例如在第 23 行，我们定义 `emp2` 时没有指定字段名称。但是通过这种方式定义的结构体变量时，字段值的顺序必须与声明结构体类型时字段的顺序保持一致。 +在定义结构体变量时也可以忽略字段名称，例如在第 23 行，我们定义 emp2 时没有指定字段名称。但是通过这种方式定义的结构体变量时，字段值的顺序必须与声明结构体类型时字段的顺序保持一致。 上面的程序输出如下： @@ -115,7 +113,7 @@ func main() { } ``` -在上面的程序中，第 8 行定义了一个**匿名结构体变量** `emp3`。正如我们之前提到的，这种结构体叫做匿名结构体，因为它只创建了一个新的结构体变量 `emp3`，而没有定义新的结构体类型。 +在上面的程序中，第3行定义了一个 匿名结构体变量 emp3。正如我们提到的一样，这种结构体成为匿名结构体，因为它只创建了一个新的结构体变量 emp3，而没有定义新的结构体类型。 程序的输出为： @@ -123,9 +121,9 @@ func main() { Employee 3 {Andreah Nikola 31 5000} ``` -## 结构体变量的零值 +## 结构体变量的 0 值 -当定义一个结构体变量，但是没有提供初始值时，结构体中的字段会被赋予它们各自类型的零值。 +当定义一个结构体变量，但是没有给它提供初始值，则对应的字段被赋予它们各自类型的0值。 ```golang package main @@ -145,13 +143,13 @@ func main() { } ``` -上面的程序定义了 `emp4` 但是没有赋予任何初值。因此 `firstName` 和 `lastName` 被赋值为 `string` 类型的零值，也就是空字符串（`""`）。`age` 和 `salary` 被赋值为 `int` 类型的零值，也就是 0。程序的输出为： +上面的程序定义了 emp4 但是没有赋予任何初值。因此 firstName 和 lastName 被赋值为 string 类型的0值，也就是空字符串。age 和 salary 被赋值为 int 类型的0值，也就是 0 。程序的输出为： ```golang Employee 4 { 0 0} ``` -我们也可以指定某些字段的值而忽略其它字段。在这种情况下，被忽略的字段被赋予相应类型的零值。 +可以指定一些字段而忽略一些字段。在这种情况下，被忽略的字段被赋予相应类型的 0 值。 ```golang package main @@ -174,7 +172,7 @@ func main() { } ``` -在上面的程序中，第14和15行，`firstName` 和 `lastName` 被提供了初始值，而 `age` 和 `salary` 没有。因此 `age` 和 `salary` 被指定为相应类型的零值。程序的输出为： +在上面的程序中，第14和15行，firstName 和 lastName 被提供了初始值，而 age 和 salary 没有。因此 age 和 salary 被指定为0值。程序的输出为： ```golang Employee 5 {John Paul 0 0} @@ -182,7 +180,7 @@ Employee 5 {John Paul 0 0} ## 访问结构体中的字段 -使用点 `.` 操作符来访问结构体中的字段。 +使用点` . `操作符来访问结构体中的字段。 ```golang package main @@ -202,24 +200,19 @@ func main() { fmt.Println("Last Name:", emp6.lastName) fmt.Println("Age:", emp6.age) fmt.Printf("Salary: $%d", emp6.salary) - emp6.salary = 6500 - fmt.Printf("New Salary: $%d", emp6.salary) } ``` -在上面的程序中，通过 `emp6.firstName` 访问 `emp6` 中的字段 `firstName`。随后我们修改了该员工的薪水，程序的输出为： +在上面的程序中，通过` emp6.firstName `访问 emp6 中的字段 firstName。程序的输出为： ```golang First Name: Sam Last Name: Anderson Age: 55 Salary: $6000 -New Salary: $6500 ``` -## 指向结构体的指针 - -我们也可以创建指向结构体的指针： +**map 的 0 值为 `nil`。试图给一个 nil map 添加元素给会导致运行时错误。因此 map 必须通过 make 来初始化** （译者注：也可以使用速记声明来创建 map，见下文）。 ```golang package main @@ -228,33 +221,39 @@ import ( "fmt" ) -type Employee struct { - firstName string - lastName string - age int - salary int -} - func main() { - emp8 := &Employee{ - firstName: "Sam", - lastName: "Anderson", - age: 55, - salary: 6000, + var personSalary map[string]int + if personSalary == nil { + fmt.Println("map is nil. Going to make one.") + personSalary = make(map[string]int) } - fmt.Println("First Name:", (*emp8).firstName) - fmt.Println("Age:", (*emp8).age) } ``` -上面的程序中，`emp8` 是一个指向 `Employee` 结构体的指针。使用`(\*emp8).firstName` 来访问 `emp8` 中的 `firstName` 字段，程序输出： +上面的程序中，`personSalary` 为 `nil`，因此使用 make 初始化它。程序的输出为：`map is nil. Going to make one`. +## 向 map 中插入元素 + +插入元素给 map 的语法与数组相似。下面的代码插入一些新的元素给 `map personSalary`。 ```golang -First Name: Sam -Age: 55 +package main + +import ( + "fmt" +) + +func main() { + personSalary := make(map[string]int) + personSalary["steve"] = 12000 + personSalary["jamie"] = 15000 + personSalary["mike"] = 9000 + fmt.Println("personSalary map contents:", personSalary) +} ``` -**Go 语言提供了一种简写方法：用 `emp8.firstName` 来代替 `(\*emp8).firstName` 的间接引用。** +上面的程序输出：`personSalary map contents: map[steve:12000 jamie:15000 mike:9000]`。 + +也可以在声明时初始化一个数组： ```golang package main @@ -263,46 +262,27 @@ import ( "fmt" ) -type Employee struct { - firstName string - lastName string - age int - salary int -} - func main() { - emp8 := &Employee{ - firstName: "Sam", - lastName: "Anderson", - age: 55, - salary: 6000, + personSalary := map[string]int { + "steve": 12000, + "jamie": 15000, } - fmt.Println("First Name:", emp8.firstName) - fmt.Println("Age:", emp8.age) + personSalary["mike"] = 9000 + fmt.Println("personSalary map contents:", personSalary) } ``` -我们用 `emp8.firstName` 来获取 `firstName` 字段，程序输出： +上面的程序在声明 personSalary 的同时向其中插入了两个元素。接着插入了一个以 "mike" 为键的元素。程序的输出为： ```golang -First Name: Sam -Age: 55 +personSalary map contents: map[steve:12000 jamie:15000 mike:9000] ``` -## 匿名字段 +`string` 并不是可以作为键的唯一类型，其他所有可以比较的类型，比如，布尔类型，整型，浮点型，复数类型都可以作为键。如果你想了解更多关于可比较类型的话，请参阅：http://golang.org/ref/spec#Comparison_operators -在创建结构体时，我们可以只定义字段的类型，不包含字段的名称。这种字段叫做匿名字段。 +## 访问 map 中的元素 -以下代码创建了一个叫 `Person` 的结构体，包含两个匿名字段：`string` 和 `int`。 - -```golang -type Person struct { - string - int -} -``` - -**尽管匿名字段没有名称，但是它的默认名称就是它的类型。** 例如，上面例子中的 `Person` 结构体，它的两个字段的默认名称是 `string` 和 `int`。 +现在我们已经添加了一些元素给 map，现在让我们学习如何从 map 中提取它们。根据键获取值的语法为：`map[key]`，例如： ```golang package main @@ -311,31 +291,20 @@ import ( "fmt" ) -type Person struct { - string - int -} - func main() { - p1 := Person{ - string: "Ricky", - int: 10, + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, } - fmt.Println(p1.string) - fmt.Println(p1.int) + personSalary["mike"] = 9000 + employee := "jamie" + fmt.Println("Salary of", employee, "is", personSalary[employee]) } ``` -在第 17 和 18 行，我们利用匿名字段的类型：`string` 和 `int`，访问了 `Person` 中的匿名字段。程序输出： +上面的程序非常简单。员工 `jamie` 的工资被取出并打印。程序的输出为：`Salary of jamie is 15000`。 -```golang -Ricky -10 -``` - -## 嵌套结构体 - -我们也可以创建一个包含结构体作为字段的结构体，这叫做嵌套结构体。例如： +如果一个键不存在会发生什么？`map` 会返回值类型的 `0 `值。比如如果访问了 `personSalary` 中的不存在的键，那么将返回 `int` 的 0 值，也就是 0。 ```golang package main @@ -344,60 +313,34 @@ import ( "fmt" ) -type Address struct { - city string - state string -} - -type Person struct { - name string - age int - address Address -} - func main() { - p := Person{ - name: "Ricky", - age: 10, - address: Address{ - city: "Chicago", - state: "Illinois", - }, + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, } - - fmt.Println("Name:", p.name) - fmt.Println("Age:", p.age) - fmt.Println("City:", p.address.city) - fmt.Println("State:", p.address.state) + personSalary["mike"] = 9000 + employee := "jamie" + fmt.Println("Salary of", employee, "is", personSalary[employee]) + fmt.Println("Salary of joe is", personSalary["joe"]) } ``` -这里，名叫 `Person` 的结构体包含一个叫做 `address` 的字段，这个字段本身也是一个结构体。以上程序输出： +上面的程序输出为: ```golang -Name: Ricky -Age: 10 -City: Chicago -State: Illinois +Salary of jamie is 15000 +Salary of joe is 0 ``` -## 提阶字段 +上面的程序返回 `joe` 的工资为` 0`。我们没有得到任何运行时错误说明键 joe 在 `personSalary` 中不存在。 -如果结构体中的匿名字段也是一个结构体，那么这个匿名结构体字段叫做提阶字段，因为我们可以通过外部结构体变量直接访问匿名结构体中的字段，就像这些字段原本属于外部结构体一样。这个定义有些复杂，所以我们来看一些代码来更好地理解这一概念： +我们如何检测一个键是否存在于一个 map 中呢？可以使用下面的语法： ```golang -type Address struct { - city string - state string -} -type Person struct { - name string - age int - Address -} +value, ok := map[key] ``` -在上面的代码中，名叫 `Person` 的结构体包含了一个匿名结构体字段 `Address`。我们将 `Address` 的字段：`city` 和 `state`，叫做提阶字段，因为我们可以在 `Person` 结构体里直接访问这两个字段，就如同这两个字段在 `Person` 结构体里被声明了一样。 +上面的语法可以检测一个特定的键是否存在于 map 中。如果 `ok` 是 `true`，则键存在，value 被赋值为对应的值。如果 `ok` 为 `false`，则表示键不存在。 ```golang package main @@ -406,150 +349,120 @@ import ( "fmt" ) -type Address struct { - city string - state string -} -type Person struct { - name string - age int - Address -} - func main() { - p := Person{ - name: "Ricky", - age: 10, - Address: Address{ - city: "Chicago", - state: "Illinois", - }, + personSalary := map[string]int{ + "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") } - fmt.Println("Name:", p.name) - fmt.Println("Age:", p.age) - fmt.Println("City:", p.city) //city is promoted field - fmt.Println("State:", p.state) //state is promoted field } ``` -在第 29 和 30 行，提阶字段 `city` 和 `state` 可以直接在结构体 `p` 中被访问（利用 `p.city` 和 `p.state` 语句），就好像这两个字段是在 `p` 中被声明的。程序输出： +在上面的程序中，第 15 行，`ok` 应该为 `false` ，因为 `joe` 不存在。因此程序的输出为： ```golang -Name: Ricky -Age: 10 -City: Chicago -State: Illinois -``` - -## 导出结构体和字段 - -如果一个结构体类型的名称以大写字母开头，那么它就是一个**导出类型**，可以被其他的包访问。同理，如果一个结构体的字段名称以大写字母开头，那么该字段也可以被其他包访问。 - -我们写一段程序，来理解这一概念： - -在 `Documents` 目录下创建一个叫做 `structs` 的文件夹（译者注：本文作者在 `Documents` 目录下创建了文件夹，你也可以根据个人喜好将文件夹创建在任何目录下）： - -``` -mkdir ~/Documents/structs +joe not found ``` -我们再来创建一个叫做 `structs` 的 Go 模块： +range for 可用于遍历 map 中所有的元素（译者注：这里 range 操作符会返回 map 的键和值）。 -``` -cd ~/Documents/structs/ -go mod init structs -``` +```golang +package main -在 `structs` 文件夹内创建另一个文件夹：`computer`： +import ( + "fmt" +) -``` -mkdir computer +func main() { + personSalary := map[string]int{ + "steve": 12000, + "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) + } +} ``` -在 `computer` 文件夹内，创建一个叫做 `spec.go` 的文件，写入以下内容： +上面的程序输出如下： ```golang -package computer - -type Spec struct { //exported struct - Maker string //exported field - Price int //exported field - model string //unexported field - -} +All items of a map +personSalary[mike] = 9000 +personSalary[steve] = 12000 +personSalary[jamie] = 15000 ``` -上面的代码创建了一个叫做 `computer` 的包，里面包含了导出类型的结构体 `Spec`，以及两个导出类型的字段：`Maker` 和 `Price`，还有一个非导出类型的字段：`model`。我们来尝试导入这个包，并使用 `Spec` 结构体。 +值得注意的是，因为 map 是无序的，因此对于程序的每次执行，不能保证使用 range for 遍历 map 的顺序总是一致的。 -在 `structs` 文件夹内创建 `main.go` 文件，并写入以下内容： +## 删除元素 + +`delete(map, key) `用于删除 map 中的 key。delete 函数没有返回值。 ```golang package main import ( - "structs/computer" "fmt" ) func main() { - spec := computer.Spec { - Maker: "apple", - Price: 50000, - } - fmt.Println("Maker:", spec.Maker) - fmt.Println("Price:", spec.Price) -} -``` - -现在，`structs` 文件夹的结构如下： + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, + } + personSalary["mike"] = 9000 + fmt.Println("map before deletion", personSalary) + delete(personSalary, "steve") + fmt.Println("map after deletion", personSalary) -``` -├── structs -│ ├── computer -│ │ └── spec.go -│ ├── go.mod -│ └── main.go +} ``` -在程序的第 4 行中，我们导入了 `computer` 包。在 13 和 14 行，我们访问了 `Spec` 结构体中的 `Maker` 和 `Price` 两个导出类型字段，会得到输出： +上面的程序删除以 `steve` 为键的元素。程序输出为： ```golang -Maker: apple -Price: 50000 +map before deletion map[steve:12000 jamie:15000 mike:9000] +map after deletion map[mike:9000 jamie:15000] ``` -如果我们试图访问非导出类型字段 `model`，编译器就会报错。我们在 `main.go` 中重新写入以下代码： +## map 的大小 + +用内置函数 `len` 获取 map 的大小： ```golang package main import ( - "structs/computer" "fmt" ) func main() { - spec := computer.Spec { - Maker: "apple", - Price: 50000, - model: "Mac Mini", - } - fmt.Println("Maker:", spec.Maker) - fmt.Println("Price:", spec.Price) + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, + } + personSalary["mike"] = 9000 + fmt.Println("length is", len(personSalary)) + } ``` -在第 12 行中，我们尝试访问非导出类型字段 `model`，这会导致编译错误： +上面程序中，`len(personSalary) `获取 `personSalary` 的大小。上面的程序输出：`length is 3`。 -``` -# structs -./main.go:12:13: unknown field 'model' in struct literal of type computer.Spec -``` +## map 是引用类型 -## 结构体的比较 - -**结构体属于值类型，如果两个结构体的字段都是可比较的，那么这两个结构体就是可比较的。如果两个结构体变量对应的字段都是相等的，那么这两个结构体就是相等的。** +与切片一样，map 是引用类型。当一个 map 赋值给一个新的变量，它们都指向同一个内部数据结构。因此改变其中一个也会反映到另一个： ```golang package main @@ -558,81 +471,141 @@ import ( "fmt" ) -type name struct { - firstName string - lastName string -} - func main() { - name1 := name{ - firstName: "Steve", - lastName: "Jobs", - } - name2 := name{ - firstName: "Steve", - lastName: "Jobs", - } - if name1 == name2 { - fmt.Println("name1 and name2 are equal") - } else { - fmt.Println("name1 and name2 are not equal") - } - - name3 := name{ - firstName: "Steve", - lastName: "Jobs", - } - name4 := name{ - firstName: "Steve", - } - - if name3 == name4 { - fmt.Println("name3 and name4 are equal") - } else { - fmt.Println("name3 and name4 are not equal") + personSalary := map[string]int{ + "steve": 12000, + "jamie": 15000, } + personSalary["mike"] = 9000 + fmt.Println("Original person salary", personSalary) + newPersonSalary := personSalary + newPersonSalary["mike"] = 18000 + fmt.Println("Person salary changed", personSalary) } ``` -上面的程序中，结构体 `name` 包含两个字符串类型的字段。由于字符串是可以比较的，我们因此可以比较两个 `name` 类型的结构体变量。程序输出： +上面的程序中，第 14 行，`personSalary` 赋值给 `newPersonSalary`。下一行，将 `newPersonSalary` 中 `mike` 的工资改为 `18000`。那么在 `personSalary` 中 `mike` 的工资也将变为 `18000`。程序的输出如下： ```golang -name1 and name2 are equal -name3 and name4 are not equal +Original person salary map[steve:12000 jamie:15000 mike:9000] +Person salary changed map[jamie:15000 mike:18000 steve:12000] ``` -**但是，如果两个结构体变量包含的字段是不可比较的，那么这两个结构体变量也不可比较。** +将 map 作为参数传递给函数也是一样的。在函数中对 map 的任何修改都会影响在调用函数中看到。 + +## 比较 map + +map 不能通过 `== `操作符比较是否相等。`== `操作符只能用来检测 map 是否为 nil。 ```golang package main -import ( - "fmt" -) +func main() { + map1 := map[string]int{ + "one": 1, + "two": 2, + } -type image struct { - data map[int]int -} + map2 := map1 -func main() { - image1 := image{ - data: map[int]int{ - 0: 155, - }} - image2 := image{ - data: map[int]int{ - 0: 155, - }} - if image1 == image2 { - fmt.Println("image1 and image2 are equal") + if map1 == map2 { } } ``` -在上面的程序中，结构体类型 `image` 包含了 `map` 类型的字段：`data`。由于 `map` 类型是不可比较的，因此 `image1` 和 `image2` 也不可以进行比较。运行以上程序会发生编译错误： +上面的程序将会报错：`invalid operation: map1 == map2 (map can only be compared to nil)`。 -``` -./prog.go:20:12: invalid operation: image1 == image2 (struct containing map[int]int cannot be compared) -``` +比较两个 map 是否相等的方式是一一比较它们的元素是否相等。我会鼓励你为此编写一个程序，使其工作：） + +我（原文作者）已经将我们讨论的所有概念汇总到一个程序中，你可以从 [github](https://github.com/golangbot/arraysandslices) 下载。 + +## 知识扩展 + +[Go编程基础视频教程笔记](https://study.163.com/course/courseLearn.htm?courseId=306002#/learn/video?lessonId=421019&courseId=306002) + +```golang +package main + +import ( + "fmt" + "sort" +) -结构体的介绍到此结束，感谢阅读。 +func main(){ + // 方式一 + var m map[int]string // 声明一个map + fmt.Println(m) + m = map[int]string{} // 初始化一个map + fmt.Println(m) + + // 方式二 + 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] +} +``` + +希望你喜欢阅读。请留下宝贵的意见和反馈:) \ No newline at end of file