11.13-11.14

README.md

@@ -9,7 +9,7 @@
 
 ## 翻译进度
 
-11.12 [接口与动态类型](eBook/11.12.md)
+11.14 [结构体、集合和高阶函数](eBook/11.14.md)
 
 ## 支持本书
 

README_gc.md

@@ -30,4 +30,4 @@ Golang 编程：245386165
 
 |更新日期    |更新内容
 |----------|------------------
-|2015-11-07|11.12 接口与动态类型
+|2015-11-10|11.14 结构体、集合和高阶函数

TOC.md

@@ -101,3 +101,5 @@
         - 11.10 [反射包](11.10.md)
         - 11.11 [Printf 和反射](11.11.md)
         - 11.12 [接口与动态类型](11.12.md)
+        - 11.13 [总结：Go 中的面向对象](11.13.md)
+        - 11.14 [结构体、集合和高阶函数](11.14.md)

eBook/11.13.md

@@ -6,14 +6,13 @@ OO 语言最重要的三个方面分别是：封装，继承和多态，在 Go
 
 - 封装（数据隐藏）：和别的 OO 语言有 4 个或更多的访问层次相比，Go 把它简化为了 2 层（参见 4.2 节的可见性规则）:
 
-	1）包范围内的：通过标识符首字母小写，`对象`只在它所在的包内可见
+	1）包范围内的：通过标识符首字母小写，`对象` 只在它所在的包内可见
 
-	2）可导出的：通过标识符首字母大写，`对象`对所在包以外也可见
+	2）可导出的：通过标识符首字母大写，`对象` 对所在包以外也可见
 
 类型只拥有自己所在包中定义的方法。
 
 - 继承：用组合实现：内嵌一个（或多个）包含想要的行为（字段和方法）的类型；多重继承可以通过内嵌多个类型实现
-
 - 多态：用接口实现：某个类型的实例可以赋给它所实现的任意接口类型的变量。类型和接口是松耦合的，并且多重继承可以通过实现多个接口实现。Go 接口不是 Java 和 C# 接口的变体，而且：接口间是不相关的，并且是大规模编程和可适应的演进型设计的关键。
 
 
@@ -21,4 +20,4 @@ OO 语言最重要的三个方面分别是：封装，继承和多态，在 Go
 
 - [目录](directory.md)
 - 上一节：[接口与动态类型](11.12.md)
-- 下一节：[结构体，集合和高阶函数](11.14.md)
+- 下一节：[结构体，集合和高阶函数](11.14.md)

eBook/11.14.md

@@ -1,4 +1,4 @@
-# 结构体，集合和高阶函数
+# 结构体、集合和高阶函数
 
 通常你在应用中定义了一个结构体，那么你也可能需要这个结构体的（指针）对象集合，比如：
 
@@ -12,7 +12,6 @@ type Car struct {
 }
 
 type Cars []*Car
-
 ```
 
 在定义所需功能时我们可以利用函数可以作为（其它函数的）参数的事实来使用高阶函数，例如：
@@ -26,7 +25,6 @@ func (cs Cars) Process(f func(car *Car)) {
 		f(c)
 	}
 }
-
 ```
 
 2）在上面的基础上，实现一个查找函数来获取子集合，并在 `Process()` 中传入一个闭包执行（这样就可以访问局部切片 `cars`）：
@@ -43,7 +41,6 @@ func (cs Cars) FindAll(f func(car *Car) bool) Cars {
     )
 	return cars
 }
-
 ```
 
 3）实现 Map 功能，产出除 car 对象以外的东西：
@@ -55,11 +52,10 @@ func (cs Cars) Map(f func(car *Car) Any) []Any {
 		ix := 0
 		cs.Process(func(c *Car) {
 				result[ix] = f(c)
-				ix++ 
+				ix++
 		})
        	return result
 }
-
 ```
 
 现在我们可以定义下面这样的具体查询：
@@ -68,7 +64,6 @@ func (cs Cars) Map(f func(car *Car) Any) []Any {
 allNewBMWs := allCars.FindAll(func(car *Car) bool {
        return (car.Manufacturer == “BMW”) && (car.BuildYear > 2010)
 })
-
 ```
 
 4）我们也可以根据入参返回不同的函数。也许我们想根据不同的厂商添加汽车到不同的集合，但是这可能会是多变的。所以我们可以定义一个函数来产生特定的添加函数和 map 集：
@@ -92,7 +87,6 @@ func MakeSortedAppender(manufacturers[]string)(func(car*Car),map[string]Cars) {
  	}
 	return appender, sortedCars
 }
-
 ```
 
 现在我们可以用它把汽车分类为独立的集合，像这样：
@@ -102,7 +96,6 @@ manufacturers := []string{“Ford”, “Aston Martin”, “Land Rover”, “B
 sortedAppender, sortedCars := MakeSortedAppender(manufacturers)
 allUnsortedCars.Process(sortedAppender)
 BMWCount := len(sortedCars[“BMW”])
-
 ```
 
 我们让这些代码在下面的程序 cars.go（此处只展示了 main() 中的代码，别的代码已经在上面展示）中执行：
@@ -117,7 +110,6 @@ import (
 	"fmt"
 )
 
-
 type Any interface{}
 type Car struct {
 	Model   	string
@@ -182,12 +174,12 @@ func (cs Cars) Map(f func(car *Car) Any) []Any {
 func MakeSortedAppender(manufacturers []string) (func(car *Car), map[string]Cars) {
      // Prepare maps of sorted cars.
        sortedCars := make(map[string]Cars)
-   
+
        for _, m := range manufacturers {
            sortedCars[m] = make([]*Car, 0)
        }
        sortedCars["Default"] = make([]*Car, 0)
-   
+
        // Prepare appender function:
        appender := func(c *Car) {
            if _, ok := sortedCars[c.Manufacturer]; ok {
@@ -198,14 +190,15 @@ func MakeSortedAppender(manufacturers []string) (func(car *Car), map[string]Cars
        }
        return appender, sortedCars
 }
+```
 
-/* Output:
+输出：
+
+```
 AllCars:  [0xf8400038a0 0xf840003bd0 0xf840003ba0 0xf840003b70]
 New BMWs:  [0xf840003bd0]
 Map sortedCars:  map[Default:[0xf840003ba0] Jaguar:[] Land Rover:[] BMW:[0xf840003bd0 0xf840003b70] Aston Martin:[] Ford:[0xf8400038a0]]
 We have  2  BMWs
-*/
-
 ```
 
 

eBook/directory.md

@@ -107,7 +107,7 @@
     - 11.11 [Printf 和反射](11.11.md)
     - 11.12 [接口与动态类型](11.12.md)
     - 11.13 [总结：Go 中的面向对象](11.13.md)
-    - 11.14 [结构体，集合和高阶函数](11.14.md)
+    - 11.14 [结构体、集合和高阶函数](11.14.md)
 
 ## 第三部分：Go 高级编程