mirror of
https://github.com/gopl-zh/gopl-zh.github.com.git
synced 2025-08-04 23:02:44 +00:00
转为 mdbook
This commit is contained in:
chai2010
228
ch4/ch4-02.md
228
ch4/ch4-02.md
@@ -125,6 +125,230 @@ make([]T, len, cap) // same as make([]T, cap)[:len]
|
||||
|
||||
在底层，make创建了一个匿名的数组变量，然后返回一个slice；只有通过返回的slice才能引用底层匿名的数组变量。在第一种语句中，slice是整个数组的view。在第二个语句中，slice只引用了底层数组的前len个元素，但是容量将包含整个的数组。额外的元素是留给未来的增长用的。
|
||||
|
||||
{% include "./ch4-02-1.md" %}
|
||||
### 4.2.1. append函数
|
||||
|
||||
{% include "./ch4-02-2.md" %}
|
||||
内置的append函数用于向slice追加元素：
|
||||
|
||||
```Go
|
||||
var runes []rune
|
||||
for _, r := range "Hello, 世界" {
|
||||
runes = append(runes, r)
|
||||
}
|
||||
fmt.Printf("%q\n", runes) // "['H' 'e' 'l' 'l' 'o' ',' ' ' '世' '界']"
|
||||
```
|
||||
|
||||
在循环中使用append函数构建一个由九个rune字符构成的slice，当然对应这个特殊的问题我们可以通过Go语言内置的[]rune("Hello, 世界")转换操作完成。
|
||||
|
||||
append函数对于理解slice底层是如何工作的非常重要，所以让我们仔细查看究竟是发生了什么。下面是第一个版本的appendInt函数，专门用于处理[]int类型的slice：
|
||||
|
||||
<u><i>gopl.io/ch4/append</i></u>
|
||||
```Go
|
||||
func appendInt(x []int, y int) []int {
|
||||
var z []int
|
||||
zlen := len(x) + 1
|
||||
if zlen <= cap(x) {
|
||||
// There is room to grow. Extend the slice.
|
||||
z = x[:zlen]
|
||||
} else {
|
||||
// There is insufficient space. Allocate a new array.
|
||||
// Grow by doubling, for amortized linear complexity.
|
||||
zcap := zlen
|
||||
if zcap < 2*len(x) {
|
||||
zcap = 2 * len(x)
|
||||
}
|
||||
z = make([]int, zlen, zcap)
|
||||
copy(z, x) // a built-in function; see text
|
||||
}
|
||||
z[len(x)] = y
|
||||
return z
|
||||
}
|
||||
```
|
||||
|
||||
每次调用appendInt函数，必须先检测slice底层数组是否有足够的容量来保存新添加的元素。如果有足够空间的话，直接扩展slice（依然在原有的底层数组之上），将新添加的y元素复制到新扩展的空间，并返回slice。因此，输入的x和输出的z共享相同的底层数组。
|
||||
|
||||
如果没有足够的增长空间的话，appendInt函数则会先分配一个足够大的slice用于保存新的结果，先将输入的x复制到新的空间，然后添加y元素。结果z和输入的x引用的将是不同的底层数组。
|
||||
|
||||
虽然通过循环复制元素更直接，不过内置的copy函数可以方便地将一个slice复制另一个相同类型的slice。copy函数的第一个参数是要复制的目标slice，第二个参数是源slice，目标和源的位置顺序和`dst = src`赋值语句是一致的。两个slice可以共享同一个底层数组，甚至有重叠也没有问题。copy函数将返回成功复制的元素的个数（我们这里没有用到），等于两个slice中较小的长度，所以我们不用担心覆盖会超出目标slice的范围。
|
||||
|
||||
为了提高内存使用效率，新分配的数组一般略大于保存x和y所需要的最低大小。通过在每次扩展数组时直接将长度翻倍从而避免了多次内存分配，也确保了添加单个元素操作的平均时间是一个常数时间。这个程序演示了效果：
|
||||
|
||||
```Go
|
||||
func main() {
|
||||
var x, y []int
|
||||
for i := 0; i < 10; i++ {
|
||||
y = appendInt(x, i)
|
||||
fmt.Printf("%d cap=%d\t%v\n", i, cap(y), y)
|
||||
x = y
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
每一次容量的变化都会导致重新分配内存和copy操作：
|
||||
|
||||
```
|
||||
0 cap=1 [0]
|
||||
1 cap=2 [0 1]
|
||||
2 cap=4 [0 1 2]
|
||||
3 cap=4 [0 1 2 3]
|
||||
4 cap=8 [0 1 2 3 4]
|
||||
5 cap=8 [0 1 2 3 4 5]
|
||||
6 cap=8 [0 1 2 3 4 5 6]
|
||||
7 cap=8 [0 1 2 3 4 5 6 7]
|
||||
8 cap=16 [0 1 2 3 4 5 6 7 8]
|
||||
9 cap=16 [0 1 2 3 4 5 6 7 8 9]
|
||||
```
|
||||
|
||||
让我们仔细查看i=3次的迭代。当时x包含了[0 1 2]三个元素，但是容量是4，因此可以简单将新的元素添加到末尾，不需要新的内存分配。然后新的y的长度和容量都是4，并且和x引用着相同的底层数组，如图4.2所示。
|
||||
|
||||
|
||||
|
||||
在下一次迭代时i=4，现在没有新的空余的空间了，因此appendInt函数分配一个容量为8的底层数组，将x的4个元素[0 1 2 3]复制到新空间的开头，然后添加新的元素i，新元素的值是4。新的y的长度是5，容量是8；后面有3个空闲的位置，三次迭代都不需要分配新的空间。当前迭代中，y和x是对应不同底层数组的view。这次操作如图4.3所示。
|
||||
|
||||
|
||||
|
||||
内置的append函数可能使用比appendInt更复杂的内存扩展策略。因此，通常我们并不知道append调用是否导致了内存的重新分配，因此我们也不能确认新的slice和原始的slice是否引用的是相同的底层数组空间。同样，我们不能确认在原先的slice上的操作是否会影响到新的slice。因此，通常是将append返回的结果直接赋值给输入的slice变量：
|
||||
|
||||
```Go
|
||||
runes = append(runes, r)
|
||||
```
|
||||
|
||||
更新slice变量不仅对调用append函数是必要的，实际上对应任何可能导致长度、容量或底层数组变化的操作都是必要的。要正确地使用slice，需要记住尽管底层数组的元素是间接访问的，但是slice对应结构体本身的指针、长度和容量部分是直接访问的。要更新这些信息需要像上面例子那样一个显式的赋值操作。从这个角度看，slice并不是一个纯粹的引用类型，它实际上是一个类似下面结构体的聚合类型：
|
||||
|
||||
```Go
|
||||
type IntSlice struct {
|
||||
ptr *int
|
||||
len, cap int
|
||||
}
|
||||
```
|
||||
|
||||
我们的appendInt函数每次只能向slice追加一个元素，但是内置的append函数则可以追加多个元素，甚至追加一个slice。
|
||||
|
||||
```Go
|
||||
var x []int
|
||||
x = append(x, 1)
|
||||
x = append(x, 2, 3)
|
||||
x = append(x, 4, 5, 6)
|
||||
x = append(x, x...) // append the slice x
|
||||
fmt.Println(x) // "[1 2 3 4 5 6 1 2 3 4 5 6]"
|
||||
```
|
||||
|
||||
通过下面的小修改，我们可以达到append函数类似的功能。其中在appendInt函数参数中的最后的“...”省略号表示接收变长的参数为slice。我们将在5.7节详细解释这个特性。
|
||||
|
||||
```Go
|
||||
func appendInt(x []int, y ...int) []int {
|
||||
var z []int
|
||||
zlen := len(x) + len(y)
|
||||
// ...expand z to at least zlen...
|
||||
copy(z[len(x):], y)
|
||||
return z
|
||||
}
|
||||
```
|
||||
|
||||
为了避免重复，和前面相同的代码并没有显示。
|
||||
|
||||
### 4.2.2. Slice内存技巧
|
||||
|
||||
让我们看看更多的例子，比如旋转slice、反转slice或在slice原有内存空间修改元素。给定一个字符串列表，下面的nonempty函数将在原有slice内存空间之上返回不包含空字符串的列表：
|
||||
|
||||
<u><i>gopl.io/ch4/nonempty</i></u>
|
||||
```Go
|
||||
// Nonempty is an example of an in-place slice algorithm.
|
||||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
// nonempty returns a slice holding only the non-empty strings.
|
||||
// The underlying array is modified during the call.
|
||||
func nonempty(strings []string) []string {
|
||||
i := 0
|
||||
for _, s := range strings {
|
||||
if s != "" {
|
||||
strings[i] = s
|
||||
i++
|
||||
}
|
||||
}
|
||||
return strings[:i]
|
||||
}
|
||||
```
|
||||
|
||||
比较微妙的地方是，输入的slice和输出的slice共享一个底层数组。这可以避免分配另一个数组，不过原来的数据将可能会被覆盖，正如下面两个打印语句看到的那样：
|
||||
|
||||
```Go
|
||||
data := []string{"one", "", "three"}
|
||||
fmt.Printf("%q\n", nonempty(data)) // `["one" "three"]`
|
||||
fmt.Printf("%q\n", data) // `["one" "three" "three"]`
|
||||
```
|
||||
|
||||
因此我们通常会这样使用nonempty函数：`data = nonempty(data)`。
|
||||
|
||||
nonempty函数也可以使用append函数实现：
|
||||
|
||||
```Go
|
||||
func nonempty2(strings []string) []string {
|
||||
out := strings[:0] // zero-length slice of original
|
||||
for _, s := range strings {
|
||||
if s != "" {
|
||||
out = append(out, s)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
```
|
||||
|
||||
无论如何实现，以这种方式重用一个slice一般都要求最多为每个输入值产生一个输出值，事实上很多这类算法都是用来过滤或合并序列中相邻的元素。这种slice用法是比较复杂的技巧，虽然使用到了slice的一些技巧，但是对于某些场合是比较清晰和有效的。
|
||||
|
||||
一个slice可以用来模拟一个stack。最初给定的空slice对应一个空的stack，然后可以使用append函数将新的值压入stack：
|
||||
|
||||
```Go
|
||||
stack = append(stack, v) // push v
|
||||
```
|
||||
|
||||
stack的顶部位置对应slice的最后一个元素：
|
||||
|
||||
```Go
|
||||
top := stack[len(stack)-1] // top of stack
|
||||
```
|
||||
|
||||
通过收缩stack可以弹出栈顶的元素
|
||||
|
||||
```Go
|
||||
stack = stack[:len(stack)-1] // pop
|
||||
```
|
||||
|
||||
要删除slice中间的某个元素并保存原有的元素顺序，可以通过内置的copy函数将后面的子slice向前依次移动一位完成：
|
||||
|
||||
```Go
|
||||
func remove(slice []int, i int) []int {
|
||||
copy(slice[i:], slice[i+1:])
|
||||
return slice[:len(slice)-1]
|
||||
}
|
||||
|
||||
func main() {
|
||||
s := []int{5, 6, 7, 8, 9}
|
||||
fmt.Println(remove(s, 2)) // "[5 6 8 9]"
|
||||
}
|
||||
```
|
||||
|
||||
如果删除元素后不用保持原来顺序的话，我们可以简单的用最后一个元素覆盖被删除的元素：
|
||||
|
||||
```Go
|
||||
func remove(slice []int, i int) []int {
|
||||
slice[i] = slice[len(slice)-1]
|
||||
return slice[:len(slice)-1]
|
||||
}
|
||||
|
||||
func main() {
|
||||
s := []int{5, 6, 7, 8, 9}
|
||||
fmt.Println(remove(s, 2)) // "[5 6 9 8]
|
||||
}
|
||||
```
|
||||
|
||||
**练习 4.3：** 重写reverse函数，使用数组指针代替slice。
|
||||
|
||||
**练习 4.4：** 编写一个rotate函数，通过一次循环完成旋转。
|
||||
|
||||
**练习 4.5：** 写一个函数在原地完成消除[]string中相邻重复的字符串的操作。
|
||||
|
||||
**练习 4.6：** 编写一个函数，原地将一个UTF-8编码的[]byte类型的slice中相邻的空格（参考unicode.IsSpace）替换成一个空格返回
|
||||
|
||||
**练习 4.7：** 修改reverse函数用于原地反转UTF-8编码的[]byte。是否可以不用分配额外的内存？
|
||||
|
||||
227
ch4/ch4-04.md
227
ch4/ch4-04.md
@@ -134,8 +134,229 @@ if _, ok := seen[s]; !ok {
|
||||
}
|
||||
```
|
||||
|
||||
{% include "./ch4-04-1.md" %}
|
||||
### 4.4.1. 结构体字面值
|
||||
|
||||
{% include "./ch4-04-2.md" %}
|
||||
结构体值也可以用结构体字面值表示，结构体字面值可以指定每个成员的值。
|
||||
|
||||
{% include "./ch4-04-3.md" %}
|
||||
```Go
|
||||
type Point struct{ X, Y int }
|
||||
|
||||
p := Point{1, 2}
|
||||
```
|
||||
|
||||
这里有两种形式的结构体字面值语法，上面的是第一种写法，要求以结构体成员定义的顺序为每个结构体成员指定一个字面值。它要求写代码和读代码的人要记住结构体的每个成员的类型和顺序，不过结构体成员有细微的调整就可能导致上述代码不能编译。因此，上述的语法一般只在定义结构体的包内部使用，或者是在较小的结构体中使用，这些结构体的成员排列比较规则，比如image.Point{x, y}或color.RGBA{red, green, blue, alpha}。
|
||||
|
||||
其实更常用的是第二种写法，以成员名字和相应的值来初始化，可以包含部分或全部的成员，如1.4节的Lissajous程序的写法：
|
||||
|
||||
```Go
|
||||
anim := gif.GIF{LoopCount: nframes}
|
||||
```
|
||||
|
||||
在这种形式的结构体字面值写法中，如果成员被忽略的话将默认用零值。因为提供了成员的名字，所以成员出现的顺序并不重要。
|
||||
|
||||
两种不同形式的写法不能混合使用。而且，你不能企图在外部包中用第一种顺序赋值的技巧来偷偷地初始化结构体中未导出的成员。
|
||||
|
||||
```Go
|
||||
package p
|
||||
type T struct{ a, b int } // a and b are not exported
|
||||
|
||||
package q
|
||||
import "p"
|
||||
var _ = p.T{a: 1, b: 2} // compile error: can't reference a, b
|
||||
var _ = p.T{1, 2} // compile error: can't reference a, b
|
||||
```
|
||||
|
||||
虽然上面最后一行代码的编译错误信息中并没有显式提到未导出的成员，但是这样企图隐式使用未导出成员的行为也是不允许的。
|
||||
|
||||
结构体可以作为函数的参数和返回值。例如，这个Scale函数将Point类型的值缩放后返回：
|
||||
|
||||
```Go
|
||||
func Scale(p Point, factor int) Point {
|
||||
return Point{p.X * factor, p.Y * factor}
|
||||
}
|
||||
|
||||
fmt.Println(Scale(Point{1, 2}, 5)) // "{5 10}"
|
||||
```
|
||||
|
||||
如果考虑效率的话，较大的结构体通常会用指针的方式传入和返回，
|
||||
|
||||
```Go
|
||||
func Bonus(e *Employee, percent int) int {
|
||||
return e.Salary * percent / 100
|
||||
}
|
||||
```
|
||||
|
||||
如果要在函数内部修改结构体成员的话，用指针传入是必须的；因为在Go语言中，所有的函数参数都是值拷贝传入的，函数参数将不再是函数调用时的原始变量。
|
||||
|
||||
```Go
|
||||
func AwardAnnualRaise(e *Employee) {
|
||||
e.Salary = e.Salary * 105 / 100
|
||||
}
|
||||
```
|
||||
|
||||
因为结构体通常通过指针处理，可以用下面的写法来创建并初始化一个结构体变量，并返回结构体的地址：
|
||||
|
||||
```Go
|
||||
pp := &Point{1, 2}
|
||||
```
|
||||
|
||||
它和下面的语句是等价的
|
||||
|
||||
```Go
|
||||
pp := new(Point)
|
||||
*pp = Point{1, 2}
|
||||
```
|
||||
|
||||
不过&Point{1, 2}写法可以直接在表达式中使用，比如一个函数调用。
|
||||
|
||||
### 4.4.2. 结构体比较
|
||||
|
||||
如果结构体的全部成员都是可以比较的，那么结构体也是可以比较的，那样的话两个结构体将可以使用==或!=运算符进行比较。相等比较运算符==将比较两个结构体的每个成员，因此下面两个比较的表达式是等价的：
|
||||
|
||||
```Go
|
||||
type Point struct{ X, Y int }
|
||||
|
||||
p := Point{1, 2}
|
||||
q := Point{2, 1}
|
||||
fmt.Println(p.X == q.X && p.Y == q.Y) // "false"
|
||||
fmt.Println(p == q) // "false"
|
||||
```
|
||||
|
||||
可比较的结构体类型和其他可比较的类型一样，可以用于map的key类型。
|
||||
|
||||
```Go
|
||||
type address struct {
|
||||
hostname string
|
||||
port int
|
||||
}
|
||||
|
||||
hits := make(map[address]int)
|
||||
hits[address{"golang.org", 443}]++
|
||||
```
|
||||
|
||||
|
||||
### 4.4.3. 结构体嵌入和匿名成员
|
||||
|
||||
在本节中，我们将看到如何使用Go语言提供的不同寻常的结构体嵌入机制让一个命名的结构体包含另一个结构体类型的匿名成员，这样就可以通过简单的点运算符x.f来访问匿名成员链中嵌套的x.d.e.f成员。
|
||||
|
||||
考虑一个二维的绘图程序，提供了一个各种图形的库，例如矩形、椭圆形、星形和轮形等几何形状。这里是其中两个的定义：
|
||||
|
||||
```Go
|
||||
type Circle struct {
|
||||
X, Y, Radius int
|
||||
}
|
||||
|
||||
type Wheel struct {
|
||||
X, Y, Radius, Spokes int
|
||||
}
|
||||
```
|
||||
|
||||
一个Circle代表的圆形类型包含了标准圆心的X和Y坐标信息，和一个Radius表示的半径信息。一个Wheel轮形除了包含Circle类型所有的全部成员外，还增加了Spokes表示径向辐条的数量。我们可以这样创建一个wheel变量：
|
||||
|
||||
```Go
|
||||
var w Wheel
|
||||
w.X = 8
|
||||
w.Y = 8
|
||||
w.Radius = 5
|
||||
w.Spokes = 20
|
||||
```
|
||||
|
||||
随着库中几何形状数量的增多，我们一定会注意到它们之间的相似和重复之处，所以我们可能为了便于维护而将相同的属性独立出来：
|
||||
|
||||
```Go
|
||||
type Point struct {
|
||||
X, Y int
|
||||
}
|
||||
|
||||
type Circle struct {
|
||||
Center Point
|
||||
Radius int
|
||||
}
|
||||
|
||||
type Wheel struct {
|
||||
Circle Circle
|
||||
Spokes int
|
||||
}
|
||||
```
|
||||
|
||||
这样改动之后结构体类型变的清晰了，但是这种修改同时也导致了访问每个成员变得繁琐：
|
||||
|
||||
```Go
|
||||
var w Wheel
|
||||
w.Circle.Center.X = 8
|
||||
w.Circle.Center.Y = 8
|
||||
w.Circle.Radius = 5
|
||||
w.Spokes = 20
|
||||
```
|
||||
|
||||
Go语言有一个特性让我们只声明一个成员对应的数据类型而不指名成员的名字；这类成员就叫匿名成员。匿名成员的数据类型必须是命名的类型或指向一个命名的类型的指针。下面的代码中，Circle和Wheel各自都有一个匿名成员。我们可以说Point类型被嵌入到了Circle结构体，同时Circle类型被嵌入到了Wheel结构体。
|
||||
|
||||
```Go
|
||||
type Circle struct {
|
||||
Point
|
||||
Radius int
|
||||
}
|
||||
|
||||
type Wheel struct {
|
||||
Circle
|
||||
Spokes int
|
||||
}
|
||||
```
|
||||
|
||||
得益于匿名嵌入的特性，我们可以直接访问叶子属性而不需要给出完整的路径：
|
||||
|
||||
```Go
|
||||
var w Wheel
|
||||
w.X = 8 // equivalent to w.Circle.Point.X = 8
|
||||
w.Y = 8 // equivalent to w.Circle.Point.Y = 8
|
||||
w.Radius = 5 // equivalent to w.Circle.Radius = 5
|
||||
w.Spokes = 20
|
||||
```
|
||||
|
||||
在右边的注释中给出的显式形式访问这些叶子成员的语法依然有效，因此匿名成员并不是真的无法访问了。其中匿名成员Circle和Point都有自己的名字——就是命名的类型名字——但是这些名字在点操作符中是可选的。我们在访问子成员的时候可以忽略任何匿名成员部分。
|
||||
|
||||
不幸的是，结构体字面值并没有简短表示匿名成员的语法， 因此下面的语句都不能编译通过：
|
||||
|
||||
```Go
|
||||
w = Wheel{8, 8, 5, 20} // compile error: unknown fields
|
||||
w = Wheel{X: 8, Y: 8, Radius: 5, Spokes: 20} // compile error: unknown fields
|
||||
```
|
||||
|
||||
结构体字面值必须遵循形状类型声明时的结构，所以我们只能用下面的两种语法，它们彼此是等价的：
|
||||
|
||||
<u><i>gopl.io/ch4/embed</i></u>
|
||||
```Go
|
||||
w = Wheel{Circle{Point{8, 8}, 5}, 20}
|
||||
|
||||
w = Wheel{
|
||||
Circle: Circle{
|
||||
Point: Point{X: 8, Y: 8},
|
||||
Radius: 5,
|
||||
},
|
||||
Spokes: 20, // NOTE: trailing comma necessary here (and at Radius)
|
||||
}
|
||||
|
||||
fmt.Printf("%#v\n", w)
|
||||
// Output:
|
||||
// Wheel{Circle:Circle{Point:Point{X:8, Y:8}, Radius:5}, Spokes:20}
|
||||
|
||||
w.X = 42
|
||||
|
||||
fmt.Printf("%#v\n", w)
|
||||
// Output:
|
||||
// Wheel{Circle:Circle{Point:Point{X:42, Y:8}, Radius:5}, Spokes:20}
|
||||
```
|
||||
|
||||
需要注意的是Printf函数中%v参数包含的#副词，它表示用和Go语言类似的语法打印值。对于结构体类型来说，将包含每个成员的名字。
|
||||
|
||||
因为匿名成员也有一个隐式的名字，因此不能同时包含两个类型相同的匿名成员，这会导致名字冲突。同时，因为成员的名字是由其类型隐式地决定的，所以匿名成员也有可见性的规则约束。在上面的例子中，Point和Circle匿名成员都是导出的。即使它们不导出（比如改成小写字母开头的point和circle），我们依然可以用简短形式访问匿名成员嵌套的成员
|
||||
|
||||
```Go
|
||||
w.X = 8 // equivalent to w.circle.point.X = 8
|
||||
```
|
||||
|
||||
但是在包外部，因为circle和point没有导出，不能访问它们的成员，因此简短的匿名成员访问语法也是禁止的。
|
||||
|
||||
到目前为止，我们看到匿名成员特性只是对访问嵌套成员的点运算符提供了简短的语法糖。稍后，我们将会看到匿名成员并不要求是结构体类型；其实任何命名的类型都可以作为结构体的匿名成员。但是为什么要嵌入一个没有任何子成员类型的匿名成员类型呢？
|
||||
|
||||
答案是匿名类型的方法集。简短的点运算符语法可以用于选择匿名成员嵌套的成员，也可以用于访问它们的方法。实际上，外层的结构体不仅仅是获得了匿名成员类型的所有成员，而且也获得了该类型导出的全部的方法。这个机制可以用于将一些有简单行为的对象组合成有复杂行为的对象。组合是Go语言中面向对象编程的核心，我们将在6.3节中专门讨论。
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
一个模板是一个字符串或一个文件，里面包含了一个或多个由双花括号包含的`{{action}}`对象。大部分的字符串只是按字面值打印，但是对于actions部分将触发其它的行为。每个actions都包含了一个用模板语言书写的表达式，一个action虽然简短但是可以输出复杂的打印值，模板语言包含通过选择结构体的成员、调用函数或方法、表达式控制流if-else语句和range循环语句，还有其它实例化模板等诸多特性。下面是一个简单的模板字符串：
|
||||
|
||||
{% raw %}
|
||||
|
||||
|
||||
<u><i>gopl.io/ch4/issuesreport</i></u>
|
||||
```Go
|
||||
@@ -19,7 +19,7 @@ Age: {{.CreatedAt | daysAgo}} days
|
||||
|
||||
{% endraw %}
|
||||
|
||||
{% raw %}
|
||||
|
||||
|
||||
这个模板先打印匹配到的issue总数，然后打印每个issue的编号、创建用户、标题还有存在的时间。对于每一个action，都有一个当前值的概念，对应点操作符，写作“.”。当前值“.”最初被初始化为调用模板时的参数，在当前例子中对应github.IssuesSearchResult类型的变量。模板中`{{.TotalCount}}`对应action将展开为结构体中TotalCount成员以默认的方式打印的值。模板中`{{range .Items}}`和`{{end}}`对应一个循环action，因此它们之间的内容可能会被展开多次，循环每次迭代的当前值对应当前的Items元素的值。
|
||||
|
||||
@@ -90,7 +90,7 @@ Age: 695 days
|
||||
|
||||
下面的模板以HTML格式输出issue列表。注意import语句的不同：
|
||||
|
||||
{% raw %}
|
||||
|
||||
|
||||
<u><i>gopl.io/ch4/issueshtml</i></u>
|
||||
```Go
|
||||
@@ -142,7 +142,7 @@ $ ./issueshtml repo:golang/go 3133 10535 >issues2.html
|
||||
|
||||
|
||||
|
||||
{% raw %}
|
||||
|
||||
|
||||
<u><i>gopl.io/ch4/autoescape</i></u>
|
||||
```Go
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
# 第四章 复合数据类型
|
||||
# 第4章 复合数据类型
|
||||
|
||||
在第三章我们讨论了基本数据类型，它们可以用于构建程序中数据的结构，是Go语言世界的原子。在本章，我们将讨论复合数据类型，它是以不同的方式组合基本类型而构造出来的复合数据类型。我们主要讨论四种类型——数组、slice、map和结构体——同时在本章的最后，我们将演示如何使用结构体来解码和编码到对应JSON格式的数据，并且通过结合使用模板来生成HTML页面。
|
||||
|
||||
|
||||
Reference in New Issue
Block a user