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

Revert "修改013 014 015 016 (#17)"

Browse Source 
This reverts commit cc5a5b9e32.
master
ShaoBo Wan(無尘) 4 years ago
parent cc5a5b9e32
commit 86cea07341
4 changed files with 530 additions and 405 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 中呢？这可以通过结构体 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` 结构体，并添加了我们创建的三个员工。

2
docs/golang_tutorial_14.md
Unescape View File

@ -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

388
docs/golang_tutorial_15.md
Unescape View File

@ -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 <nil>
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) 上创建了一个简单的小程序，包含了我们这次所学的全部内容。
希望你喜欢阅读。请留下宝贵的意见和反馈:)

541
docs/golang_tutorial_16.md
Unescape View File

@ -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]
}
```
希望你喜欢阅读。请留下宝贵的意见和反馈:)
Write Preview
Loading…
Cancel
Save