modified: eBook/18.1.md

	modified:   eBook/18.11.md
	modified:   eBook/18.2.md
	modified:   eBook/18.3.md
	modified:   eBook/18.4.md
	modified:   eBook/18.8.md

eBook/18.1.md

@@ -30,22 +30,24 @@ for ix, ch := range str {
 
 （4）如何获取一个字符串的字节数：`len(str)`
 
-    如何获取一个字符串的字符数：
+ 如何获取一个字符串的字符数：
+
+ 最快速：
 
-    最快速：
  ```go
  utf8.RuneCountInString(str)
  ```   
-    `len([]int(str)) //TBD`
+
+ `len([]int(str)) //TBD`
 
 （5）如何连接字符串：
 
-    最快速: 
-    `with a bytes.Buffer`（参考[章节7.2](07.2.md)）
+ 最快速: 
+`with a bytes.Buffer`（参考[章节7.2](07.2.md)）
 
-    `Strings.Join()`（参考[章节4.7](04.7.md)）
+`Strings.Join()`（参考[章节4.7](04.7.md)）
     
-    `+=`
+`+=`
 
  ```go
  str1 := "Hello " 

eBook/18.11.md

@@ -26,5 +26,5 @@
 ## 链接
 
 - [目录](directory.md)
-- 上一章：[运算符模板和接口](17.4.md)
-- 下一节：[字符串](18.1.md)
+- 上一节：[其他](18.10.md)
+- 下一章：[构建一个完整的应用程序](19.0.md)

eBook/18.2.md

@@ -1,14 +1,11 @@
 # 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}`
-
-            `arrKeyValue := [len]type{i1: val1, i2: val2}`
-
-            `var slice1 []type = arr1[start:end]`
+初始化：`arr1 := [...]type{i1, i2, i3, i4, i5}`
+        `arrKeyValue := [len]type{i1: val1, i2: val2}`
+        `var slice1 []type = arr1[start:end]`
 
 （1）如何截断数组或者切片的最后一个元素：
 
@@ -25,7 +22,7 @@ for ix, value := range arr {
 }
 ```
 
-（3）如何在一个二维数组或者切片arr2Dim中查找一个指定值V：
+（3）如何在一个二维数组或者切片`arr2Dim`中查找一个指定值`V`：
 
 ```go
 found := false

eBook/18.3.md

@@ -1,7 +1,7 @@
 # 18.3 映射
 
-    创建：    `map1 := make(map[keytype]valuetype)`
-    初始化:   `map1 := map[string]int{"one": 1, "two": 2}`
+创建：    `map1 := make(map[keytype]valuetype)`
+初始化:   `map1 := map[string]int{"one": 1, "two": 2}`
 
 （1）如何使用`for`或者`for-range`遍历一个映射：
 
@@ -13,13 +13,13 @@ for key, value := range map1 {
 
 （2）如何在一个映射中检测键key1是否存在：
 
-    `val1, isPresent = map1[key1]`
+`val1, isPresent = map1[key1]`
 
-    返回值:  键`key1`对应的值或者`0`, `true`或者`false`
+返回值:  键`key1`对应的值或者`0`, `true`或者`false`
     
 （3）如何在映射中删除一个键：
 
-    `delete(map1, key1)`
+`delete(map1, key1)`
 
 ## 链接
 

eBook/18.4.md

@@ -1,7 +1,6 @@
 # 18.4 结构体
 
-    创建：
-
+创建：
 ```go
 type struct1 struct {
     field1 type1
@@ -11,14 +10,13 @@ type struct1 struct {
 ms := new(struct1)
 ```
 
-    初始化: 
-
+初始化: 
 ```go
 ms := &struct1{10, 15.5, "Chris"}
 ```
 
-    当结构体的命名以大写字母开头时，该结构体在包外可见。
-    通常情况下，为每个结构体定义一个构建函数，并推荐使用构建函数初始化结构体（参考例10.2）：
+当结构体的命名以大写字母开头时，该结构体在包外可见。
+通常情况下，为每个结构体定义一个构建函数，并推荐使用构建函数初始化结构体（参考例10.2）：
 
 ```go    
 ms := Newstruct1{10, 15.5, "Chris"}

eBook/18.8.md

@@ -1,22 +1,20 @@
 # 18.8 协程（goroutine）与通道（channel）
 
-    出于性能考虑的建议：
+出于性能考虑的建议：
     
-    实践经验表明，如果你使用并行性获得高于串行运算的效率：在协程内部已经完成的大部分工作，其开销比创建协程和协程间通信还高。
+实践经验表明，如果你使用并行性获得高于串行运算的效率：在协程内部已经完成的大部分工作，其开销比创建协程和协程间通信还高。
 
-    1 出于出于性能考虑建议使用带缓存的通道：
-    使用带缓存的通道很轻易成倍提高它的吞吐量，某些场景其性能可以提高至10倍甚至更多。通过调整通道的容量，你可以尝试着更进一步的优化其的性能。
+1 出于出于性能考虑建议使用带缓存的通道：
 
-    2 限制一个通道的数据数量并将它们封装在成一个数组：
+使用带缓存的通道很轻易成倍提高它的吞吐量，某些场景其性能可以提高至10倍甚至更多。通过调整通道的容量，你可以尝试着更进一步的优化其的性能。
 
-    如果使用通道传递大量单独的数据，那么通道将变成你的性能瓶颈。然而，当将数据块打包封装成数组，在接收端解压数据时，性能可以提高至10倍。
+2 限制一个通道的数据数量并将它们封装在成一个数组：
 
+如果使用通道传递大量单独的数据，那么通道将变成你的性能瓶颈。然而，当将数据块打包封装成数组，在接收端解压数据时，性能可以提高至10倍。
 
-    创建：`ch := make(chan type, buf)`
-
-
-    （1）如何使用`for`或者`for-range`遍历一个通道：
+创建：`ch := make(chan type, buf)`
 
+（1）如何使用`for`或者`for-range`遍历一个通道：
 
 ```go
 for v := range ch {
@@ -24,8 +22,7 @@ for v := range ch {
 }
 ```
 
-    （2）如何检测一个通道`ch`是否是关闭的：
-
+（2）如何检测一个通道`ch`是否是关闭的：
 
 ```go
 //read channel until it closes or error-condition
@@ -37,10 +34,11 @@ for {
 }
 ```
 
-    或者使用（1）自动检测。
+或者使用（1）自动检测。
+
+（3）如何通过一个通道让主程序等待直到协程完成：
+（信号量模式）：
 
-    （3）如何通过一个通道让主程序等待直到协程完成：
-        （信号量模式）：
 ```go
 ch := make(chan int) // Allocate a channel.
 // Start something in a goroutine; when it completes, signal on the channel.
@@ -52,11 +50,9 @@ doSomethingElseForAWhile()
 <-ch // Wait for goroutine to finish; discard sent value.
 ```
 
+如果希望程序必须一直阻塞，在匿名函数中省略 `ch <- 1`即可。
 
-    如果希望程序必须一直阻塞，在匿名函数中省略 `ch <- 1`即可。
-
-
-    （4）通道的工厂模板：下面的函数是一个通道工厂，启动一个匿名函数作为协程以生产通道
+（4）通道的工厂模板：下面的函数是一个通道工厂，启动一个匿名函数作为协程以生产通道
 
 ```go
 func pump() chan int {
@@ -70,17 +66,15 @@ func pump() chan int {
 }
 ```
        
-    （5）通道迭代器模板：
-    
-    （6）如何限制并发处理请求的数量：参考14.11小节
-    
-    （7）如何在多核CPU上实现并行计算：参考14.13小节
+（5）通道迭代器模板：
+  
+（6）如何限制并发处理请求的数量：参考14.11小节
+
+（7）如何在多核CPU上实现并行计算：参考14.13小节
 
+ (8)如何停止一个协程：`runtime.Goexit()`  
 
-     (8)如何停止一个协程：`runtime.Goexit()`  
-      
- 
-    （9）简单的超时模板：
+（9）简单的超时模板：
 
 ```go  
 timeout := make(chan bool, 1)
@@ -96,7 +90,7 @@ select {
 }
 ```
 
-    （10）如何使用输入通道和输出通道代替锁：
+（10）如何使用输入通道和输出通道代替锁：
 
 ```go
 func Worker(in, out chan *Task) {
@@ -108,11 +102,11 @@ func Worker(in, out chan *Task) {
 }
 ```
 
-    （11）如何在同步调用运行时间过长时将之丢弃：参考14.5小节 第二个变体
+（11）如何在同步调用运行时间过长时将之丢弃：参考14.5小节 第二个变体
 
-    （12）如何在通道中使用计时器和定时器：参考14.5小节
+（12）如何在通道中使用计时器和定时器：参考14.5小节
 
-    （13）典型的服务器后端模型：参考14.4小节
+（13）典型的服务器后端模型：参考14.4小节
 
 ## 链接