7x31/the-way-to-go_ZH_CN
1
0
Fork 0
mirror of https://github.com/unknwon/the-way-to-go_ZH_CN.git synced 2025-08-11 19:41:43 +08:00
Code Issues Packages Projects Releases Wiki Activity

第十七十八章 (#833)

Browse Source 
Co-authored-by: Joe Chen <jc@unknwon.io>
This commit is contained in:
Haigang Zhou
2022-05-19 19:57:23 +08:00
committed by GitHub
parent 72bc74ab95
commit fa1cfcc67f
12 changed files with 66 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
eBook/17.1.md
View File

@@ -1,8 +1,8 @@
# 17.1 逗号 ok 模式
在学习本书第二部分和第三部分时，我们经常在一个表达式返回 2 个参数时使用这种模式：`,ok`，第一个参数是一个值或者 `nil`，第二个参数是 `true`/`false` 或者一个错误 `error`。在一个需要赋值的 `if` 条件语句中，使用这种模式去检测第二个参数值会让代码显得优雅简洁。这种模式在 go 语言编码规范中非常重要。下面总结了所有使用这种模式的例子：
在学习本书第二部分和第三部分时，我们经常在一个表达式返回 2 个参数时使用这种模式：`something, ok`，第一个参数是一个值或者 `nil`，第二个参数是 `true`/`false` 或者一个错误 `error`。在一个需要赋值的 `if` 条件语句中，使用这种模式去检测第二个参数值会让代码显得优雅简洁。这种模式在 Go 语言编码规范中非常重要。下面总结了所有使用这种模式的例子：
（1）在函数返回时检测错误（参考[第5.2小节](05.2.md)）:
（1）在函数返回时检测错误（参考[第 5.2 小节](05.2.md)）:
```go
value, err := pack1.Func1(param1)
@@ -32,11 +32,11 @@ func SomeFunc() error {
}
```
这种模式也常用于通过 `defer` 使程序从 `panic` 中恢复执行（参考[第17.2(4)小节](17.2.md)）。
这种模式也常用于通过 `defer` 使程序从 `panic` 中恢复执行（参考[第 17.2(4) 小节](17.2.md)）。
要实现简洁的错误检测代码，更好的方式是使用闭包，参考[第16.10.2小节](16.10.md)
要实现简洁的错误检测代码，更好的方式是使用闭包，参考[第 16.10.2 小节](16.10.md)
（2）检测映射中是否存在一个键值（参考[第8.2小节](08.2.md)）：`key1` 在映射 `map1` 中是否有值？
（2）检测映射中是否存在一个键值（参考[第 8.2 小节](08.2.md)）：`key1` 在映射 `map1` 中是否有值？
```go
if value, isPresent = map1[key1]; isPresent {
@@ -46,7 +46,7 @@ if value, isPresent = map1[key1]; isPresent {
…
```
（3）检测一个接口类型变量 `varI` 是否包含了类型 `T`：类型断言（参考[第11.3小节](11.3.md)）：
（3）检测一个接口类型变量 `varI` 是否包含了类型 `T`：类型断言（参考[第 11.3 小节](11.3.md)）：
```go
if value, ok := varI.(T); ok {
@@ -55,7 +55,7 @@ if value, ok := varI.(T); ok {
// 接口类型 varI 没有包含类型 T
```
（4）检测一个通道 `ch` 是否关闭（参考[第14.3小节](14.3.md)）：
（4）检测一个通道 `ch` 是否关闭（参考[第 14.3 小节](14.3.md)）：
```go
for input := range ch {

2
eBook/17.3.md
View File

@@ -1,6 +1,6 @@
# 17.3 可见性模式
我们在 [4.2.1节](04.2.md) 见过简单地使用可见性规则控制对类型成员的访问，他们可以是 Go 变量或函数。[10.2.1节](10.2.md) 展示了如何在单独的包中定义类型时，强制使用工厂函数。
我们在 [4.2.1 节](04.2.md)见过简单地使用可见性规则控制对类型成员的访问，他们可以是 Go 变量或函数。[10.2.1 节](10.2.md)展示了如何在单独的包中定义类型时，强制使用工厂函数。
## 链接

19
eBook/18.1.md
View File

@@ -30,20 +30,19 @@ for ix, ch := range str {
（4）如何获取一个字符串的字节数：`len(str)`
如何获取一个字符串的字符数：
如何获取一个字符串的字符数：
最快速：`utf8.RuneCountInString(str)`
（最快速）使用 `utf8.RuneCountInString(str)`
`len([]rune(str))`
或使用 `len([]rune(str))`
（5）如何连接字符串：
最快速：
`with a bytes.Buffer`（参考[章节7.2](07.2.md)）
（最快速）使用 `bytes.Buffer`（参考[章节 7.2](07.2.md)）
`Strings.Join()`（参考[章节4.7](04.7.md)）
使用 `+=`：
或使用 `Strings.Join()`（参考[章节 4.7](04.7.md)）
或使用 `+=`：
```go
str1 := "Hello "
@@ -51,9 +50,7 @@ for ix, ch := range str {
str1 += str2 //str1 == "Hello World!"
```
（6）如何解析命令行参数：使用 `os` 或者 `flag` 包
（参考[例12.4](examples/chapter_12/fileinput.go)）
（6）如何解析命令行参数：使用 `os` 或者 `flag` 包（参考[例 12.4](examples/chapter_12/fileinput.go)）
## 链接

5
eBook/18.11.md
View File

@@ -6,7 +6,7 @@
（3）尽可能的使用切片代替数组；
（4）尽可能的使用数组和切片代替映射（详见参考文献15）；
（4）尽可能的使用数组和切片代替映射（详见参考文献 15）；
（5）如果只想获取切片中某项值，不需要值的索引，尽可能的使用 `for range` 去遍历切片，这比必须查询切片中的每个元素要快一些；
@@ -20,7 +20,8 @@
（10）尽可能在需要分配大量内存时使用缓存；
（11）使用缓存模板（参考[章节15.7](15.7.md)）。
（11）使用缓存模板（参考[章节 15.7](15.7.md)）。
## 链接

16
eBook/18.2.md
View File

@@ -1,22 +1,22 @@
# 18.2 数组和切片
创建：
- 创建：
`arr1 := new([len]type)`
`arr1 := new([len]type)`
`slice1 := make([]type, len)`
`slice1 := make([]type, len)`
初始化：
- 初始化：
`arr1 := [...]type{i1, i2, i3, i4, i5}`
`arr1 := [...]type{i1, i2, i3, i4, i5}`
`arrKeyValue := [len]type{i1: val1, i2: val2}`
`arrKeyValue := [len]type{i1: val1, i2: val2}`
`var slice1 []type = arr1[start:end]`
`var slice1 []type = arr1[start:end]`
（1）如何截断数组或者切片的最后一个元素：
`line = line[:len(line)-1]`
​ `line = line[:len(line)-1]`
（2）如何使用 `for` 或者 `for-range` 遍历一个数组（或者切片）：

8
eBook/18.3.md
View File

@@ -14,13 +14,11 @@ for key, value := range map1 {
（2）如何在一个映射中检测键 `key1` 是否存在：
`val1, isPresent = map1[key1]`
`val1, isPresent = map1[key1]`
返回值：键 `key1` 对应的值或者 `0`，`true` 或者 `false`
（3）如何在映射中删除一个键：
返回值：键 `key1` 对应的值或者 `0`，`true` 或者 `false`
`delete(map1, key1)`
（3）如何在映射中删除一个键：`delete(map1, key1)`
## 链接

9
eBook/18.4.md
View File

@@ -1,6 +1,6 @@
# 18.4 结构体
创建：
- 创建：
```go
type struct1 struct {
@@ -11,14 +11,15 @@ type struct1 struct {
ms := new(struct1)
```
初始化：
- 初始化：
```go
ms := &struct1{10, 15.5, "Chris"}
```
当结构体的命名以大写字母开头时，该结构体在包外可见。
通常情况下，为每个结构体定义一个构建函数，并推荐使用构建函数初始化结构体（参考[例10.2](examples/chapter_10/person.go)）：
通常情况下，为每个结构体定义一个构建函数，并推荐使用构建函数初始化结构体（参考[例 10.2](examples/chapter_10/person.go)）：
```go
ms := Newstruct1{10, 15.5, "Chris"}
@@ -31,4 +32,4 @@ func Newstruct1(n int, f float32, name string) *struct1 {
- [目录](directory.md)
- 上一节：[映射](18.3.md)
- 下一节：[接口](18.5.md)
- 下一节：[接口](18.5.md)

2
eBook/18.5.md
View File

@@ -9,7 +9,7 @@ if v, ok := v.(Stringer); ok {
```
（2）如何使用接口实现一个类型分类函数：
```go
func classifier(items ...interface{}) {
for i, x := range items {

4
eBook/18.6.md
View File

@@ -1,7 +1,7 @@
# 18.6 函数
如何使用内建函数 `recover` 终止 `panic` 过程（参考[章节13.3](13.3.md)）：
如何使用内建函数 `recover()` 终止 `panic()` 过程（参考[章节 13.3](13.3.md)）：
```go
func protect(g func()) {
defer func() {

5
eBook/18.7.md
View File

@@ -1,7 +1,7 @@
# 18.7 文件
（1）如何打开一个文件并读取：
```go
file, err := os.Open("input.dat")
if err != nil {
@@ -22,7 +22,6 @@ file, err := os.Open("input.dat")
```
（2）如何通过切片读写文件：
```go
func cat(f *file.File) {
const NBUF = 512
@@ -49,4 +48,4 @@ func cat(f *file.File) {
- [目录](directory.md)
- 上一节：[函数](18.6.md)
- 下一节：[协程（goroutine）与通道（channel）](18.8.md)
- 下一节：[协程 (goroutine) 与通道 (channel)](18.8.md)

40
eBook/18.8.md
View File

@@ -1,18 +1,18 @@
# 18.8 协程（goroutine）与通道（channel）
# 18.8 协程 (goroutine) 与通道 (channel)
出于性能考虑的建议：
实践经验表明，为了使并行运算获得高于串行运算的效率，在协程内部完成的工作量，必须远远高于协程的创建和相互来回通信的开销。
1 出于性能考虑建议使用带缓存的通道：
- 出于性能考虑建议使用带缓存的通道：
使用带缓存的通道可以很轻易成倍提高它的吞吐量，某些场景其性能可以提高至 10 倍甚至更多。通过调整通道的容量，甚至可以尝试着更进一步的优化其性能。
使用带缓存的通道可以很轻易成倍提高它的吞吐量，某些场景其性能可以提高至 10 倍甚至更多。通过调整通道的容量，甚至可以尝试着更进一步的优化其性能。
2 限制一个通道的数据数量并将它们封装成一个数组：
- 限制一个通道的数据数量并将它们封装成一个数组：
如果使用通道传递大量单独的数据，那么通道将变成性能瓶颈。然而，将数据块打包封装成数组，在接收端解压数据时，性能可以提高至 10 倍。
如果使用通道传递大量单独的数据，那么通道将变成性能瓶颈。然而，将数据块打包封装成数组，在接收端解压数据时，性能可以提高至 10 倍。
创建：`ch := make(chan type,buf)`
现在创建一个带缓存的通道：`ch := make(chan type,buf)`
（1）如何使用 `for` 或者 `for-range` 遍历一个通道：
@@ -34,11 +34,9 @@ for {
}
```
或者使用（1）自动检测。
或者使用（1）自动检测。
（3）如何通过一个通道让主程序等待直到协程完成：
（信号量模式）：
（3）如何通过一个通道让主程序等待直到协程完成（信号量模式）：
```go
ch := make(chan int) // Allocate a channel.
@@ -51,7 +49,7 @@ doSomethingElseForAWhile()
<-ch // Wait for goroutine to finish; discard sent value.
```
如果希望程序一直阻塞，在匿名函数中省略 `ch <- 1` 即可。
如果希望程序一直阻塞，在匿名函数中省略 `ch <- 1` 即可。
（4）通道的工厂模板：以下函数是一个通道工厂，启动一个匿名函数作为协程以生产通道：
@@ -66,12 +64,13 @@ func pump() chan int {
return ch
}
```
（5）通道迭代器模板：
（6）如何限制并发处理请求的数量：参考[章节14.11](14.11.md)
（7）如何在多核CPU上实现并行计算：参考[章节14.13](14.13.md)
（5）通道迭代器模板：（注：这里原书没有写东西，但是应该是参考[章节 14.2.10](14.2.md)）
（6）如何限制并发处理请求的数量：参考[章节 14.11](14.11.md)
（7）如何在多核CPU上实现并行计算：参考[章节 14.13](14.13.md)
（8）如何终止一个协程：`runtime.Goexit()`
@@ -103,11 +102,14 @@ func Worker(in, out chan *Task) {
}
```
（11）如何在同步调用运行时间过长时将之丢弃：参考[章节14.5](14.5.md) 第二个变体
（11）如何在同步调用运行时间过长时将之丢弃：参考[章节 14.5](14.5.md) 第二个变体
（12）如何在通道中使用计时器和定时器：参考[章节14.5](14.5.md)
（13）典型的服务器后端模型：参考[章节14.4](14.4.md)
（12）如何在通道中使用计时器和定时器：参考[章节 14.5](14.5.md)
（13）典型的服务器后端模型：参考[章节 14.4](14.4.md)
## 链接

9
eBook/18.9.md
View File

@@ -9,13 +9,14 @@ var strTempl = template.Must(template.New("TName").Parse(strTemplateHTML))
```
在网页应用中使用 HTML 过滤器过滤 HTML 特殊字符：
`{{html .}}` 或者通过一个字段 `FieldName {{ .FieldName |html }}`
使用缓存模板（参考[章节15.7](15.7.md)）
使用 `{{html .}}` 或者通过一个字段 `FieldName {{ .FieldName |html }}`
使用缓存模板（参考[章节 15.7](15.7.md)）
## 链接
- [目录](directory.md)
- 上一节：[协程（goroutine）与通道（channel）](18.8.md)
- 上一节：[协程 (goroutine) 与通道 (channel)](18.8.md)
- 下一节：[其他](18.10.md)