msb-public
/
golang-tutorial
mirror of https://github.com/Tinywan/golang-tutorial.git
1
0
Code Issues Projects Releases Wiki Activity

修改013 014 015 016 (#17)

Browse Source 
* Update golang_tutorial_05.md

* Update golang_tutorial_08.md

* Update golang_tutorial_11.md

* Update golang_tutorial_11.md

* Update golang_tutorial_12.md

* Update golang_tutorial_13.md

* Update golang_tutorial_13.md

* Update golang_tutorial_14.md

* Update golang_tutorial_14.md

* Update golang_tutorial_15.md

* Update golang_tutorial_15.md

* Update golang_tutorial_15.md

* Update golang_tutorial_15.md

* Update golang_tutorial_15.md

* Update golang_tutorial_13.md

* Update golang_tutorial_16.md

* Update golang_tutorial_15.md

* Update golang_tutorial_16.md

* Update golang_tutorial_16.md

* Update golang_tutorial_16.md

* Update golang_tutorial_16.md
pull/18/head
RickyWang1020 5 years ago committed by GitHub
parent fe48e6de52
commit cc5a5b9e32
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 405 additions and 530 deletions
Show Stats Download Patch File Download Diff File

4
docs/golang_tutorial_13.md
Unescape View File

@ -251,7 +251,7 @@ map after deletion map[mike:9000 jamie:15000]
## 结构体 map （Map of Structs） ## 结构体 map （Map of Structs）
目前我们编写了存储员工工资的 map，那么可否将员工的国籍也存储在 map 中呢？这可以通过结构体 map 来完成。每个员工可以用一个包含了“工资”和“国籍”的结构体来表示，这些结构体将被存储在一个键为 `string` 类型，值为 `struct` 类型的 map 中。 目前我们编写了存储员工工资的 map，那么可否将员工的国籍也存储在 map 中呢？这可以通过结构体 map 来完成。每个员工可以用一个包含了 `salary` 和 `country` 字段的结构体来表示，这些结构体将被存储在一个键为 `string` 类型，值为 `struct` 类型的 map 中。
```golang ```golang
package main package main
@ -291,7 +291,7 @@ func main() {
} }
``` ```
以上程序中，`employee` 结构体包含了 `salary` 和 `country`。 以上程序中，`employee` 结构体包含了 `salary` 和 `country` 两个字段。
在第25行，我们创建了一个 map，键为字符串类型，值为 `employee` 结构体，并添加了我们创建的三个员工。 在第25行，我们创建了一个 map，键为字符串类型，值为 `employee` 结构体，并添加了我们创建的三个员工。

372
docs/golang_tutorial_15.md
Unescape View File

@ -2,10 +2,10 @@
15 - 指针 15 - 指针
======================== ========================
上一节：[第十篇 if else 语句](/docs/golang_tutorial_10.md) 上一节：[第十四篇 字符串](/docs/golang_tutorial_14.md)
下一节：[第十二篇 包](/docs/golang_tutorial_12.md) 下一节：[第十六篇 结构体](/docs/golang_tutorial_16.md)
这是本Golang系列教程的第15篇。 这是本Golang系列教程的第15篇。我们将学习 Go 语言中指针的作用，并且将 Go 指针与其他语言（如 C/C++）的指针进行区分。
## 什么是指针？ ## 什么是指针？
@ -13,13 +13,14 @@
![pointer-explained](../images/pointer-explained.png) ![pointer-explained](../images/pointer-explained.png)
在上图中，变量 `b` 的值是 `156`，存储在地址为 `0x1040a124` 的内存中。变量 `a` 存储了变量 `b` 的地址。现在可以说 `a` 指向 `b`。 在上图中，变量 `b` 的值是 `156`，存储在地址为 `0x1040a124` 的内存中。变量 `a` 存储了变量 `b` 的地址，也可以说 `a` 指向 `b`。
## 指针的声明 ## 指针的声明
指向类型 `T` 的指针用 `*T` 表示。 指向类型 `T` 的指针用 `*T` 表示。
让我们写一些代码。 让我们写一些代码。
```golang ```golang
package main package main
@ -36,24 +37,17 @@ 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 Type of a is *int
address of b is 0x1040a124 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 ```golang
package main package main
@ -63,38 +57,28 @@ import (
) )
func main() { func main() {
var personSalary map[string]int a := 25
if personSalary == nil { var b *int
fmt.Println("map is nil. Going to make one.") if b == nil {
personSalary = make(map[string]int) fmt.Println("b is", b)
b = &a
fmt.Println("b after initialization is", b)
} }
} }
``` ```
上面的程序中，`personSalary` 为 `nil`，因此使用 `make` 初始化它。程序的输出为：`map is nil. Going to make one`. 'b' 首先被初始化为 `nil`，之后被赋值为 `a` 的地址，程序输出为：
## 向 map 中插入元素
插入元素给 `map` 的语法与数组相似。下面的代码插入一些新的元素给 `map personSalary`。
```golang ```golang
package main b is <nil>
b after initialization is 0x1040a124
import (
"fmt"
)
func main() {
personSalary := make(map[string]int)
personSalary["steve"] = 12000
personSalary["jamie"] = 15000
personSalary["mike"] = 9000
fmt.Println("personSalary map contents:", personSalary)
}
``` ```
上面的程序输出：`personSalary map contents: map[steve:12000 jamie:15000 mike:9000]`。 ## 利用 `new` 函数创建指针
也可以在声明时初始化一个数组： Go 还提供一个实用的函数 `new` 来创建指针。`new` 函数接收一个类型，并返回一个该类型的零值指针。
我们来看一个实例：
```golang ```golang
package main package main
@ -104,48 +88,48 @@ import (
) )
func main() { func main() {
personSalary := map[string]int { size := new(int)
"steve": 12000, fmt.Printf("Size value is %d, type is %T, address is %v\n", *size, size, size)
"jamie": 15000, *size = 85
} fmt.Println("New size value is", *size)
personSalary["mike"] = 9000
fmt.Println("personSalary map contents:", personSalary)
} }
``` ```
上面的程序在声明 `personSalary` 的同时向其中插入了两个元素。接着插入了一个以 `"mike"` 为键的元素。程序的输出为： 上面的程序中，我们在第 8 行利用 `new` 函数创建了一个指向 `int` 类型的指针。由于 `int` 类型的零值为 `0`，变量 `size` 是一个指向 `0` 的整数指针（`*int` 类型）。
程序输出：
```golang ```golang
personSalary map contents: map[steve:12000 jamie:15000 mike:9000] Size value is 0, type is *int, address is 0x414020
New size value is 85
``` ```
`string` 并不是可以作为键的唯一类型，其他所有可以比较的类型，比如，布尔类型，整型，浮点型，复数类型都可以作为键。如果你想了解更多关于可比较类型的话，请参阅：http://golang.org/ref/spec#Comparison_operators ## 指针的间接引用
## 访问 map 中的元素 间接引用（dereference）指针就是获取指针所指向的变量的值。间接引用 `a` 的语句是 `*a`。例如：
现在我们已经添加了一些元素给 `map`，现在让我们学习如何从 `map` 中提取它们。根据键获取值的语法为：`map[key]`，例如：
```golang ```golang
package main package main
import ( import (
"fmt" "fmt"
) )
func main() { func main() {
personSalary := map[string]int{ b := 255
"steve": 12000, a := &b
"jamie": 15000, fmt.Println("address of b is", a)
} fmt.Println("value of b is", *a)
personSalary["mike"] = 9000
employee := "jamie"
fmt.Println("Salary of", employee, "is", personSalary[employee])
} }
``` ```
上面的程序非常简单。员工 `jamie` 的工资被取出并打印。程序的输出为：`Salary of jamie is 15000`。 在第 10 行，我们间接引用了 `a` 并打印了它的值，也就是 `b` 的值。程序输出为：
如果一个键不存在会发生什么？`map` 会返回值类型的 `0 `值。比如如果访问了 `personSalary` 中的不存在的键，那么将返回 `int` 的 0 值，也就是 0。 ```golang
address of b is 0x1040a124
value of b is 255
```
我们再编写一个利用指针改变变量 `b` 的值的程序：
```golang ```golang
package main package main
@ -155,33 +139,24 @@ import (
) )
func main() { func main() {
personSalary := map[string]int{ b := 255
"steve": 12000, a := &b
"jamie": 15000, fmt.Println("address of b is", a)
} fmt.Println("value of b is", *a)
personSalary["mike"] = 9000 *a++
employee := "jamie" fmt.Println("new value of b is", b)
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 ```golang
Salary of jamie is 15000 address of b is 0x1040a124
Salary of joe is 0 value of b is 255
``` new value of b is 256
上面的程序返回 `joe` 的工资为` 0`。我们没有得到任何运行时错误说明键 `joe` 在 `personSalary` 中不存在。
我们如何检测一个键是否存在于一个 `map` 中呢？可以使用下面的语法：
```golang
value, ok := map[key]
``` ```
上面的语法可以检测一个特定的键是否存在于 `map` 中。如果 `ok` 是 `true`，则键存在，value 被赋值为对应的值。如果 `ok` 为 `false`，则表示键不存在。 ## 将指针传入函数
```golang ```golang
package main package main
@ -190,30 +165,28 @@ import (
"fmt" "fmt"
) )
func main() { func change(val *int) {
personSalary := map[string]int{ *val = 55
"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() {
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)
} }
``` ```
在上面的程序中，第 15 行，`ok` 应该为 `false` ，因为 `joe` 不存在。因此程序的输出为： 在第 14 行，我们将存有 `a` 的地址的指针 `b` 传入了 `change` 函数。`change` 函数通过间接引用的方法改变了 `a` 的值，程序输出：
```golang ```golang
joe not found value of a before function call is 58
value of a after function call is 55
``` ```
`range for` 可用于遍历 `map` 中所有的元素（译者注：这里 `range` 操作符会返回 `map` 的键和值）。 ## 从函数中返回指针
从函数中返回一个局部变量的指针是完全可以的，Go 语言的编译器会将这个变量分配到堆中。
```golang ```golang
package main package main
@ -222,33 +195,25 @@ import (
"fmt" "fmt"
) )
func main() { func hello() *int {
personSalary := map[string]int{ i := 5
"steve": 12000, return &i
"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)
} }
func main() {
d := hello()
fmt.Println("Value of d", *d)
} }
``` ```
上面的程序输出如下： 在第 9 行中，我们从 `hello` 函数中返回了局部变量 `i` 的地址。 **该操作在 C/C++ 等语言中是未定义的，因为一旦 `hello` 函数执行“返回”之后，变量 `i` 就不再存在于当前域（scope）内了。但是在 Go 语言中，编译器会进行“逃逸分析”（escape analysis）并且在地址离开当前域时将 `i` 分配到堆中。** 因此这一程序可以运行，输出为：
```golang ```golang
All items of a map Value of d 5
personSalary[mike] = 9000
personSalary[steve] = 12000
personSalary[jamie] = 15000
``` ```
值得注意的是，因为 `map` 是无序的，因此对于程序的每次执行，不能保证使用 `range for` 遍历 `map` 的顺序总是一致的。 ## 不要将指向数组的指针传入函数中！要用切片
## 删除元素 假设我们想要在一个函数内部对一个数组进行更改，一种实现方法是将一个指向数组的指针传入函数。
`delete(map, key) `用于删除 `map` 中的 `key`。`delete` 函数没有返回值。
```golang ```golang
package main package main
@ -257,29 +222,20 @@ import (
"fmt" "fmt"
) )
func main() { func modify(arr *[3]int) {
personSalary := map[string]int{ (*arr)[0] = 90
"steve": 12000,
"jamie": 15000,
} }
personSalary["mike"] = 9000
fmt.Println("map before deletion", personSalary)
delete(personSalary, "steve")
fmt.Println("map after deletion", personSalary)
func main() {
a := [3]int{89, 90, 91}
modify(&a)
fmt.Println(a)
} }
``` ```
上面的程序删除以 `steve` 为键的元素。程序输出为： 在第 13 行，我们将数组 `a` 的地址传入 `modify` 函数。在第 8 行，`modify` 函数内，我们间接引用了 `arr` 并且将数组的第一个元素改为 `90`。这个程序会输出：`[90 90 91]`。
```golang **a[x] 是 (\*a)[x] 的简写形式，所以上面程序中的 (\*arr)[0] 可以被 arr[0] 代替。** 我们用简写方法重写这个程序：
map before deletion map[steve:12000 jamie:15000 mike:9000]
map after deletion map[mike:9000 jamie:15000]
```
## map 的大小
用内置函数 `len` 获取 map 的大小：
```golang ```golang
package main package main
@ -288,22 +244,22 @@ import (
"fmt" "fmt"
) )
func main() { func modify(arr *[3]int) {
personSalary := map[string]int{ arr[0] = 90
"steve": 12000,
"jamie": 15000,
} }
personSalary["mike"] = 9000
fmt.Println("length is", len(personSalary))
func main() {
a := [3]int{89, 90, 91}
modify(&a)
fmt.Println(a)
} }
``` ```
上面程序中，`len(personSalary) `获取 `personSalary` 的大小。上面的程序输出：`length is 3`。 这个程序也会输出：`[90 90 91]`。
## map 是引用类型 **尽管我们可以通过将指向数组的指针传入函数中来对数组进行修改，但是这在 Go 语言中并不是地道的方式，我们应该用切片来解决这类问题。**
与切片一样，map 是引用类型。当一个 map 赋值给一个新的变量，它们都指向同一个内部数据结构。因此改变其中一个也会反映到另一个： 我们用切片来重写之前的程序：
```golang ```golang
package main package main
@ -312,141 +268,33 @@ import (
"fmt" "fmt"
) )
func main() { func modify(sls []int) {
personSalary := map[string]int{ sls[0] = 90
"steve": 12000,
"jamie": 15000,
}
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
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
func main() { func main() {
map1 := map[string]int{ a := [3]int{89, 90, 91}
"one": 1, modify(a[:])
"two": 2, fmt.Println(a)
}
map2 := map1
if map1 == map2 {
}
} }
``` ```
上面的程序将会报错：`invalid operation: map1 == map2 (map can only be compared to nil)`。 在第 13 行，我们将一个切片传入了 `modify` 函数，这个函数将切片的第一个元素改为 `90`，程序输出仍然是：`[90 90 91]`。 **因此，不要再把指向数组的指针传入函数了，应该使用的是切片 :)**
比较两个 map 是否相等的方式是一一比较它们的元素是否相等。我会鼓励你为此编写一个程序，使其工作：）
我（原文作者）已经将我们讨论的所有概念汇总到一个程序中，你可以从 [github](https://github.com/golangbot/arraysandslices) 下载。 ## Go 不支持指针的算术运算
## 知识扩展 不像 C/C++ 中的指针可以进行算术运算，Go 语言并不支持指针算术运算。
[Go编程基础视频教程笔记](https://study.163.com/course/courseLearn.htm?courseId=306002#/learn/video?lessonId=421019&courseId=306002)
```golang ```golang
package main package main
import (
"fmt"
"sort"
)
func main() { func main() {
// 方式一 b := [...]int{109, 110, 111}
var m map[int]string // 声明一个map p := &b
fmt.Println(m) p++
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]
} }
``` ```
希望你喜欢阅读。请留下宝贵的意见和反馈:) 上面的程序会出现编译错误：`main.go:6: invalid operation: p++ (non-numeric type *[3]int)`。
我（原文作者）在 [github](https://github.com/golangbot/pointers) 上创建了一个简单的小程序，包含了我们这次所学的全部内容。

529
docs/golang_tutorial_16.md
Unescape View File

@ -1,8 +1,8 @@
16 - 结构体 16 - 结构体
======================== ========================
上一节：[第十篇 if else 语句](/docs/golang_tutorial_10.md) 上一节：[第十五篇 指针](/docs/golang_tutorial_15.md)
下一节：[第十二篇 包](/docs/golang_tutorial_12.md) 下一节：[第十七篇 方法](/docs/golang_tutorial_17.md)
这是本Golang系列教程的第16篇。 这是本Golang系列教程的第16篇。
@ -10,7 +10,7 @@
结构体（struct）是用户自定义的类型，它代表若干字段的集合。有些时候将多个数据看做一个整体要比单独使用这些数据更有意义，这种情况下就适合使用结构体。 结构体（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 ```golang
type Employee struct { type Employee struct {
@ -31,9 +31,11 @@ type Employee struct {
} }
``` ```
上面的结构体 `Employee` 是一个**具名结构体`（named structure）`**，因为它创建了一个具有名字的结构体类型： `Employee` 。我们可以定义具名结构体类型的变量。 *(尽管以上语句节省了代码行数，但是这会导致字段定义不够清晰，请尽量避免使用以上语句的定义方式)*
我们也可以定义一个没有类型名称的结构体，这种结构体叫做**匿名结构体（anonymous structures）**。 上面的结构体 `Employee` 是一个**具名结构体 `（named structs）`** ，因为它创建了一个具有名字的结构体类型：`Employee`。我们可以定义具名结构体类型的变量。
我们也可以定义一个没有类型名称的结构体，这种结构体叫做**匿名结构体 `（anonymous structs）`**。
```golang ```golang
var employee struct { var employee struct {
@ -42,11 +44,11 @@ var employee struct {
} }
``` ```
上面的代码片段声明了一个匿名结构体变量 employee。 上面的代码片段声明了一个匿名结构体变量 `employee`。
## 定义具名结构体变量 ## 定义具名结构体变量
下面的程序说明了如何定义一个具名结构体 Employee 的变量。 下面的程序说明了如何定义一个具名结构体 `Employee` 的变量。
```golang ```golang
package main package main
@ -78,9 +80,9 @@ func main() {
} }
``` ```
在上面的程序中，我们定义了一个名为 `Employee` 的结构体类型。我们可以通过指定字段的名称和对应的值来创建一个结构体变量，比如在第15行，我们就是通过这种方式定义了 `Employee` 类型的一个结构体变量 `empl`。这里字段名称的顺序没必要和声明结构体类型时的一致。例如这里我们将 `lastName` 放在了最后，程序同样正确运行。 在上面的程序中，我们定义了一个名为 `Employee` 的结构体类型。我们可以通过指定字段的名称和对应的值来创建一个结构体变量，比如在第 15 行，我们就是通过这种方式定义了 `Employee` 类型的一个结构体变量 `emp1`。这里字段名称的顺序没必要和声明结构体类型时的一致。例如这里我们将 `lastName` 放在了最后，程序同样正确运行。
在定义结构体变量时也可以忽略字段名称，例如在第 23 行，我们定义 emp2 时没有指定字段名称。但是通过这种方式定义的结构体变量时，字段值的顺序必须与声明结构体类型时字段的顺序保持一致。 在定义结构体变量时也可以忽略字段名称，例如在第 23 行，我们定义 `emp2` 时没有指定字段名称。但是通过这种方式定义的结构体变量时，字段值的顺序必须与声明结构体类型时字段的顺序保持一致。
上面的程序输出如下： 上面的程序输出如下：
@ -113,7 +115,7 @@ func main() {
} }
``` ```
在上面的程序中，第3行定义了一个 匿名结构体变量 emp3。正如我们提到的一样，这种结构体成为匿名结构体，因为它只创建了一个新的结构体变量 emp3，而没有定义新的结构体类型。 在上面的程序中，第 8 行定义了一个**匿名结构体变量** `emp3`。正如我们之前提到的，这种结构体叫做匿名结构体，因为它只创建了一个新的结构体变量 `emp3`，而没有定义新的结构体类型。
程序的输出为： 程序的输出为：
@ -121,9 +123,9 @@ func main() {
Employee 3 {Andreah Nikola 31 5000} Employee 3 {Andreah Nikola 31 5000}
``` ```
## 结构体变量的 0 值 ## 结构体变量的零值
当定义一个结构体变量，但是没有给它提供初始值，则对应的字段被赋予它们各自类型的0值。 当定义一个结构体变量，但是没有提供初始值时，结构体中的字段会被赋予它们各自类型的零值。
```golang ```golang
package main package main
@ -143,13 +145,13 @@ func main() {
} }
``` ```
上面的程序定义了 emp4 但是没有赋予任何初值。因此 firstName 和 lastName 被赋值为 string 类型的0值，也就是空字符串。age 和 salary 被赋值为 int 类型的0值，也就是 0 。程序的输出为： 上面的程序定义了 `emp4` 但是没有赋予任何初值。因此 `firstName` 和 `lastName` 被赋值为 `string` 类型的零值，也就是空字符串（`""`）。`age` 和 `salary` 被赋值为 `int` 类型的零值，也就是 0。程序的输出为：
```golang ```golang
Employee 4 { 0 0} Employee 4 { 0 0}
``` ```
可以指定一些字段而忽略一些字段。在这种情况下，被忽略的字段被赋予相应类型的 0 值。 我们也可以指定某些字段的值而忽略其它字段。在这种情况下，被忽略的字段被赋予相应类型的零值。
```golang ```golang
package main package main
@ -172,7 +174,7 @@ func main() {
} }
``` ```
在上面的程序中，第14和15行，firstName 和 lastName 被提供了初始值，而 age 和 salary 没有。因此 age 和 salary 被指定为0值。程序的输出为： 在上面的程序中，第14和15行，`firstName` 和 `lastName` 被提供了初始值，而 `age` 和 `salary` 没有。因此 `age` 和 `salary` 被指定为相应类型的零值。程序的输出为：
```golang ```golang
Employee 5 {John Paul 0 0} Employee 5 {John Paul 0 0}
@ -200,19 +202,24 @@ func main() {
fmt.Println("Last Name:", emp6.lastName) fmt.Println("Last Name:", emp6.lastName)
fmt.Println("Age:", emp6.age) fmt.Println("Age:", emp6.age)
fmt.Printf("Salary: $%d", emp6.salary) 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 ```golang
First Name: Sam First Name: Sam
Last Name: Anderson Last Name: Anderson
Age: 55 Age: 55
Salary: $6000 Salary: $6000
New Salary: $6500
``` ```
**map 的 0 值为 `nil`。试图给一个 nil map 添加元素给会导致运行时错误。因此 map 必须通过 make 来初始化** （译者注：也可以使用速记声明来创建 map，见下文）。 ## 指向结构体的指针
我们也可以创建指向结构体的指针：
```golang ```golang
package main package main
@ -221,39 +228,33 @@ import (
"fmt" "fmt"
) )
type Employee struct {
firstName string
lastName string
age int
salary int
}
func main() { func main() {
var personSalary map[string]int emp8 := &Employee{
if personSalary == nil { firstName: "Sam",
fmt.Println("map is nil. Going to make one.") lastName: "Anderson",
personSalary = make(map[string]int) age: 55,
salary: 6000,
} }
fmt.Println("First Name:", (*emp8).firstName)
fmt.Println("Age:", (*emp8).age)
} }
``` ```
上面的程序中，`personSalary` 为 `nil`，因此使用 make 初始化它。程序的输出为：`map is nil. Going to make one`. 上面的程序中，`emp8` 是一个指向 `Employee` 结构体的指针。使用`(\*emp8).firstName` 来访问 `emp8` 中的 `firstName` 字段，程序输出：
## 向 map 中插入元素
插入元素给 map 的语法与数组相似。下面的代码插入一些新的元素给 `map personSalary`。
```golang ```golang
package main First Name: Sam
Age: 55
import (
"fmt"
)
func main() {
personSalary := make(map[string]int)
personSalary["steve"] = 12000
personSalary["jamie"] = 15000
personSalary["mike"] = 9000
fmt.Println("personSalary map contents:", personSalary)
}
``` ```
上面的程序输出：`personSalary map contents: map[steve:12000 jamie:15000 mike:9000]`。 **Go 语言提供了一种简写方法：用 `emp8.firstName` 来代替 `(\*emp8).firstName` 的间接引用。**
也可以在声明时初始化一个数组：
```golang ```golang
package main package main
@ -262,27 +263,46 @@ import (
"fmt" "fmt"
) )
type Employee struct {
firstName string
lastName string
age int
salary int
}
func main() { func main() {
personSalary := map[string]int { emp8 := &Employee{
"steve": 12000, firstName: "Sam",
"jamie": 15000, lastName: "Anderson",
age: 55,
salary: 6000,
} }
personSalary["mike"] = 9000 fmt.Println("First Name:", emp8.firstName)
fmt.Println("personSalary map contents:", personSalary) fmt.Println("Age:", emp8.age)
} }
``` ```
上面的程序在声明 personSalary 的同时向其中插入了两个元素。接着插入了一个以 "mike" 为键的元素。程序的输出为： 我们用 `emp8.firstName` 来获取 `firstName` 字段，程序输出：
```golang ```golang
personSalary map contents: map[steve:12000 jamie:15000 mike:9000] First Name: Sam
Age: 55
``` ```
`string` 并不是可以作为键的唯一类型，其他所有可以比较的类型，比如，布尔类型，整型，浮点型，复数类型都可以作为键。如果你想了解更多关于可比较类型的话，请参阅：http://golang.org/ref/spec#Comparison_operators ## 匿名字段
在创建结构体时，我们可以只定义字段的类型，不包含字段的名称。这种字段叫做匿名字段。
## 访问 map 中的元素 以下代码创建了一个叫 `Person` 的结构体，包含两个匿名字段：`string` 和 `int`。
```golang
type Person struct {
string
int
}
```
现在我们已经添加了一些元素给 map，现在让我们学习如何从 map 中提取它们。根据键获取值的语法为：`map[key]`，例如： **尽管匿名字段没有名称，但是它的默认名称就是它的类型。** 例如，上面例子中的 `Person` 结构体，它的两个字段的默认名称是 `string` 和 `int`。
```golang ```golang
package main package main
@ -291,20 +311,31 @@ import (
"fmt" "fmt"
) )
type Person struct {
string
int
}
func main() { func main() {
personSalary := map[string]int{ p1 := Person{
"steve": 12000, string: "Ricky",
"jamie": 15000, int: 10,
} }
personSalary["mike"] = 9000 fmt.Println(p1.string)
employee := "jamie" fmt.Println(p1.int)
fmt.Println("Salary of", employee, "is", personSalary[employee])
} }
``` ```
上面的程序非常简单。员工 `jamie` 的工资被取出并打印。程序的输出为：`Salary of jamie is 15000`。 在第 17 和 18 行，我们利用匿名字段的类型：`string` 和 `int`，访问了 `Person` 中的匿名字段。程序输出：
如果一个键不存在会发生什么？`map` 会返回值类型的 `0 `值。比如如果访问了 `personSalary` 中的不存在的键，那么将返回 `int` 的 0 值，也就是 0。 ```golang
Ricky
10
```
## 嵌套结构体
我们也可以创建一个包含结构体作为字段的结构体，这叫做嵌套结构体。例如：
```golang ```golang
package main package main
@ -313,34 +344,60 @@ import (
"fmt" "fmt"
) )
type Address struct {
city string
state string
}
type Person struct {
name string
age int
address Address
}
func main() { func main() {
personSalary := map[string]int{ p := Person{
"steve": 12000, name: "Ricky",
"jamie": 15000, age: 10,
address: Address{
city: "Chicago",
state: "Illinois",
},
} }
personSalary["mike"] = 9000
employee := "jamie" fmt.Println("Name:", p.name)
fmt.Println("Salary of", employee, "is", personSalary[employee]) fmt.Println("Age:", p.age)
fmt.Println("Salary of joe is", personSalary["joe"]) fmt.Println("City:", p.address.city)
fmt.Println("State:", p.address.state)
} }
``` ```
上面的程序输出为: 这里，名叫 `Person` 的结构体包含一个叫做 `address` 的字段，这个字段本身也是一个结构体。以上程序输出：
```golang ```golang
Salary of jamie is 15000 Name: Ricky
Salary of joe is 0 Age: 10
City: Chicago
State: Illinois
``` ```
上面的程序返回 `joe` 的工资为` 0`。我们没有得到任何运行时错误说明键 joe 在 `personSalary` 中不存在。 ## 提阶字段
我们如何检测一个键是否存在于一个 map 中呢？可以使用下面的语法： 如果结构体中的匿名字段也是一个结构体，那么这个匿名结构体字段叫做提阶字段，因为我们可以通过外部结构体变量直接访问匿名结构体中的字段，就像这些字段原本属于外部结构体一样。这个定义有些复杂，所以我们来看一些代码来更好地理解这一概念：
```golang ```golang
value, ok := map[key] type Address struct {
city string
state string
}
type Person struct {
name string
age int
Address
}
``` ```
上面的语法可以检测一个特定的键是否存在于 map 中。如果 `ok` 是 `true`，则键存在，value 被赋值为对应的值。如果 `ok` 为 `false`，则表示键不存在。 在上面的代码中，名叫 `Person` 的结构体包含了一个匿名结构体字段 `Address`。我们将 `Address` 的字段：`city` 和 `state`，叫做提阶字段，因为我们可以在 `Person` 结构体里直接访问这两个字段，就如同这两个字段在 `Person` 结构体里被声明了一样。
```golang ```golang
package main package main
@ -349,263 +406,233 @@ import (
"fmt" "fmt"
) )
type Address struct {
city string
state string
}
type Person struct {
name string
age int
Address
}
func main() { func main() {
personSalary := map[string]int{ p := Person{
"steve": 12000, name: "Ricky",
"jamie": 15000, age: 10,
} Address: Address{
personSalary["mike"] = 9000 city: "Chicago",
newEmp := "joe" state: "Illinois",
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
} }
``` ```
在上面的程序中，第 15 行，`ok` 应该为 `false` ，因为 `joe` 不存在。因此程序的输出为： 在第 29 和 30 行，提阶字段 `city` 和 `state` 可以直接在结构体 `p` 中被访问（利用 `p.city` 和 `p.state` 语句），就好像这两个字段是在 `p` 中被声明的。程序输出：
```golang ```golang
joe not found Name: Ricky
Age: 10
City: Chicago
State: Illinois
``` ```
range for 可用于遍历 map 中所有的元素（译者注：这里 range 操作符会返回 map 的键和值）。 ## 导出结构体和字段
```golang 如果一个结构体类型的名称以大写字母开头，那么它就是一个**导出类型**，可以被其他的包访问。同理，如果一个结构体的字段名称以大写字母开头，那么该字段也可以被其他包访问。
package main
import ( 我们写一段程序，来理解这一概念：
"fmt"
) 在 `Documents` 目录下创建一个叫做 `structs` 的文件夹（译者注：本文作者在 `Documents` 目录下创建了文件夹，你也可以根据个人喜好将文件夹创建在任何目录下）：
func main() { ```
personSalary := map[string]int{ mkdir ~/Documents/structs
"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)
}
}
``` ```
上面的程序输出如下： 我们再来创建一个叫做 `structs` 的 Go 模块：
```golang ```
All items of a map cd ~/Documents/structs/
personSalary[mike] = 9000 go mod init structs
personSalary[steve] = 12000
personSalary[jamie] = 15000
``` ```
值得注意的是，因为 map 是无序的，因此对于程序的每次执行，不能保证使用 range for 遍历 map 的顺序总是一致的。 在 `structs` 文件夹内创建另一个文件夹：`computer`：
## 删除元素 ```
mkdir computer
```
`delete(map, key) `用于删除 map 中的 key。delete 函数没有返回值。 在 `computer` 文件夹内，创建一个叫做 `spec.go` 的文件，写入以下内容：
```golang ```golang
package main package computer
import ( type Spec struct { //exported struct
"fmt" Maker string //exported field
) Price int //exported field
model string //unexported field
func main() {
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)
} }
``` ```
上面的程序删除以 `steve` 为键的元素。程序输出为： 上面的代码创建了一个叫做 `computer` 的包，里面包含了导出类型的结构体 `Spec`，以及两个导出类型的字段：`Maker` 和 `Price`，还有一个非导出类型的字段：`model`。我们来尝试导入这个包，并使用 `Spec` 结构体。
```golang
map before deletion map[steve:12000 jamie:15000 mike:9000]
map after deletion map[mike:9000 jamie:15000]
```
## map 的大小
用内置函数 `len` 获取 map 的大小： 在 `structs` 文件夹内创建 `main.go` 文件，并写入以下内容：
```golang ```golang
package main package main
import ( import (
"structs/computer"
"fmt" "fmt"
) )
func main() { func main() {
personSalary := map[string]int{ spec := computer.Spec {
"steve": 12000, Maker: "apple",
"jamie": 15000, Price: 50000,
} }
personSalary["mike"] = 9000 fmt.Println("Maker:", spec.Maker)
fmt.Println("length is", len(personSalary)) fmt.Println("Price:", spec.Price)
} }
``` ```
上面程序中，`len(personSalary) `获取 `personSalary` 的大小。上面的程序输出：`length is 3`。 现在，`structs` 文件夹的结构如下：
## map 是引用类型 ```
├── structs
│ ├── computer
│ │ └── spec.go
│ ├── go.mod
│ └── main.go
```
与切片一样，map 是引用类型。当一个 map 赋值给一个新的变量，它们都指向同一个内部数据结构。因此改变其中一个也会反映到另一个： 在程序的第 4 行中，我们导入了 `computer` 包。在 13 和 14 行，我们访问了 `Spec` 结构体中的 `Maker` 和 `Price` 两个导出类型字段，会得到输出：
```golang
Maker: apple
Price: 50000
```
如果我们试图访问非导出类型字段 `model`，编译器就会报错。我们在 `main.go` 中重新写入以下代码：
```golang ```golang
package main package main
import ( import (
"structs/computer"
"fmt" "fmt"
) )
func main() { func main() {
personSalary := map[string]int{ spec := computer.Spec {
"steve": 12000, Maker: "apple",
"jamie": 15000, Price: 50000,
model: "Mac Mini",
} }
personSalary["mike"] = 9000 fmt.Println("Maker:", spec.Maker)
fmt.Println("Original person salary", personSalary) fmt.Println("Price:", spec.Price)
newPersonSalary := personSalary
newPersonSalary["mike"] = 18000
fmt.Println("Person salary changed", personSalary)
} }
``` ```
上面的程序中，第 14 行，`personSalary` 赋值给 `newPersonSalary`。下一行，将 `newPersonSalary` 中 `mike` 的工资改为 `18000`。那么在 `personSalary` 中 `mike` 的工资也将变为 `18000`。程序的输出如下： 在第 12 行中，我们尝试访问非导出类型字段 `model`，这会导致编译错误：
```golang ```
Original person salary map[steve:12000 jamie:15000 mike:9000] # structs
Person salary changed map[jamie:15000 mike:18000 steve:12000] ./main.go:12:13: unknown field 'model' in struct literal of type computer.Spec
``` ```
将 map 作为参数传递给函数也是一样的。在函数中对 map 的任何修改都会影响在调用函数中看到。 ## 结构体的比较
## 比较 map
map 不能通过 `== `操作符比较是否相等。`== `操作符只能用来检测 map 是否为 nil。 **结构体属于值类型，如果两个结构体的字段都是可比较的，那么这两个结构体就是可比较的。如果两个结构体变量对应的字段都是相等的，那么这两个结构体就是相等的。**
```golang ```golang
package main package main
import (
"fmt"
)
type name struct {
firstName string
lastName string
}
func main() { func main() {
map1 := map[string]int{ name1 := name{
"one": 1, firstName: "Steve",
"two": 2, 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")
} }
map2 := map1 name3 := name{
firstName: "Steve",
lastName: "Jobs",
}
name4 := name{
firstName: "Steve",
}
if map1 == map2 { if name3 == name4 {
fmt.Println("name3 and name4 are equal")
} else {
fmt.Println("name3 and name4 are not equal")
} }
} }
``` ```
上面的程序将会报错：`invalid operation: map1 == map2 (map can only be compared to nil)`。 上面的程序中，结构体 `name` 包含两个字符串类型的字段。由于字符串是可以比较的，我们因此可以比较两个 `name` 类型的结构体变量。程序输出：
比较两个 map 是否相等的方式是一一比较它们的元素是否相等。我会鼓励你为此编写一个程序，使其工作：）
我（原文作者）已经将我们讨论的所有概念汇总到一个程序中，你可以从 [github](https://github.com/golangbot/arraysandslices) 下载。 ```golang
name1 and name2 are equal
## 知识扩展 name3 and name4 are not equal
```
[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"
) )
type image struct {
data map[int]int
}
func main() { func main() {
// 方式一 image1 := image{
var m map[int]string // 声明一个map data: map[int]int{
fmt.Println(m) 0: 155,
m = map[int]string{} // 初始化一个map }}
fmt.Println(m) image2 := image{
data: map[int]int{
// 方式二 0: 155,
var m2 map[int]string = map[int]string{} }}
fmt.Println(m2) if image1 == image2 {
fmt.Println("image1 and image2 are equal")
// 方式三 }
m3 := map[int]string{} }
fmt.Println(m3) ```
// 设置、获取、删除 在上面的程序中，结构体类型 `image` 包含了 `map` 类型的字段：`data`。由于 `map` 类型是不可比较的，因此 `image1` 和 `image2` 也不可以进行比较。运行以上程序会发生编译错误：
m3[1] = "Tinywan"
a := m3[1] ```
fmt.Println(m3) // map[1:Tinywan] ./prog.go:20:12: invalid operation: image1 == image2 (struct containing map[int]int cannot be compared)
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]
}
```
希望你喜欢阅读。请留下宝贵的意见和反馈:)

Write Preview
Loading…
Cancel
Save