diff --git a/README.md b/README.md
index f9d1608..d4a5904 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
 
 ## 翻译进度
 
-6.11 [计算函数执行时间](eBook/06.11.md)
+6.12 [通过内存缓存来提升性能](eBook/06.12.md)
 
 ## 支持本书
 
diff --git a/eBook/06.12.md b/eBook/06.12.md
index 5e5443c..194e482 100644
--- a/eBook/06.12.md
+++ b/eBook/06.12.md
@@ -1,3 +1,61 @@
 # 6.12 通过内存缓存来提升性能
 
-154
\ No newline at end of file
+当在进行大量的计算时，提升性能最直接有效的一种方式就是避免重复计算。通过在内存中缓存和重复利用相同计算的结果，称之为内存缓存。最明显的例子就是生成斐波那契数列的程序（详见第 6.6 和 6.11 节）：
+
+要计算数列中第 n 个数字，需要先得到之前两个数的值，但很明显绝大多数情况下前两个数的值都是已经计算过的。即每个更后面的数都是基于之前计算结果的重复计算，正如 listing 6.11 - fibonnaci.go 所展示的那样。
+
+而我们要做就是将第 n 个数的值存在数组中索引为 n 的位置（详见第 7 章），然后在数组中查找是否已经计算过，如果没有找到，则再进行计算。
+
+程序 Listing 6.17 - fibonacci_memoization.go 就是依照这个原则实现的，下面是计算到第 40 位数字的性能对比：
+
+- 普通写法：4.730270 秒
+- 内存缓存：0.001000 秒
+
+内存缓存的优势显而易见，而且您还可以将它应用到其它类型的计算中，例如使用 map（详见第 7 章）而不是数组或切片（Listing 6.21 - fibonacci_memoization.go）：
+
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+const LIM = 41
+
+var fibs [LIM]uint64
+
+func main() {
+	var result uint64 = 0
+	start := time.Now()
+	for i := 0; i < LIM; i++ {
+		result = fibonacci(i)
+		fmt.Printf("fibonacci(%d) is: %d\n", i, result)
+	}
+	end := time.Now()
+	delta := end.Sub(start)
+	fmt.Printf("longCalculation took this amount of time: %s\n", delta)
+}
+func fibonacci(n int) (res uint64) {
+	// memoization: check if fibonacci(n) is already known in array:
+	if fibs[n] != 0 {
+		res = fibs[n]
+		return
+	}
+	if n <= 1 {
+		res = 1
+	} else {
+		res = fibonacci(n-1) + fibonacci(n-2)
+	}
+	fibs[n] = res
+	return
+}
+```
+
+内存缓存的技术在使用计算成本相对昂贵的函数时非常有用（不仅限于例子中的递归），譬如大量进行相同参数的运算。这种技术还可以应用于纯函数中，即相同输入必定获得相同输出的函数。
+
+## 链接
+
+- [目录](directory.md)
+- 上一节：[计算函数执行时间](06.11.md)
+- 下一章：[数组与切片](07.0.md)
\ No newline at end of file
diff --git a/eBook/07.0.md b/eBook/07.0.md
index 5e2e585..335ef2a 100644
--- a/eBook/07.0.md
+++ b/eBook/07.0.md
@@ -1,4 +1,7 @@
-#7.0 数组与分片
+# 7.0 数组与分片
+
+157
+
 这章我们开始剖析*容器*, 它是可以包含大量条目(item)的数据结构, 像 arrays(slices) / maps。从这看到 Go 明显受到 Python 影响。
 
 以[ ]符号标识的数组类型几乎在所有的编程语言中都是一个基本主力。Go语言中的数组也是类似的，只是有一些特点。Go没有C那么灵活，但是拥有分片（slice）类型。这是一种建立在Go语言数组类型智商的抽象，要想理解slice我们必须先理解数组。数组有特定的用处，但是却有一些呆板，所以在Go语言的代码里并不是特别常见。相对的，slice确实随处可见的。它们构建在数组之上并且提供更强大的能力和便捷。
diff --git a/eBook/directory.md b/eBook/directory.md
index 64ca896..5879560 100644
--- a/eBook/directory.md
+++ b/eBook/directory.md
@@ -58,7 +58,7 @@
 	- 6.10 [使用闭包调试](06.10.md)
 	- 6.11 [计算函数执行时间](06.11.md)
 	- 6.12 [通过内存缓存来提升性能](06.12.md)
-- 第7章：数组（array）与切片（slice）
+- 第7章：[数组与切片](07.0.md)
 - 第8章：Maps
 - 第9章：包（package）
 - 第10章：结构（struct）与方法（method）