diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..2c4fb9326bd871edcbc6dd93f1127e00a5622209
Binary files /dev/null and b/.DS_Store differ
diff --git a/chap-34-benchmarks/.DS_Store b/chap-34-benchmarks/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..6ea29bd170f15b8a97f08e55a9f7f706b49efd49
Binary files /dev/null and b/chap-34-benchmarks/.DS_Store differ
diff --git a/chap-34-benchmarks/imgs/benchmark_results.d02152ba.png b/chap-34-benchmarks/imgs/benchmark_results.d02152ba.png
new file mode 100644
index 0000000000000000000000000000000000000000..74c29843761a5f172749df72aa8ad1f3749dc7af
Binary files /dev/null and b/chap-34-benchmarks/imgs/benchmark_results.d02152ba.png differ
diff --git "a/chap-34-benchmarks/\347\254\25434\347\253\240\357\274\232benchmarks\357\274\210\345\237\272\345\207\206\346\265\213\350\257\225\357\274\211.md" "b/chap-34-benchmarks/\347\254\25434\347\253\240\357\274\232benchmarks\357\274\210\345\237\272\345\207\206\346\265\213\350\257\225\357\274\211.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9817edbd371303dedba6edfb828780385b2c9e13
--- /dev/null
+++ "b/chap-34-benchmarks/\347\254\25434\347\253\240\357\274\232benchmarks\357\274\210\345\237\272\345\207\206\346\265\213\350\257\225\357\274\211.md"
@@ -0,0 +1,652 @@
+# 第34章：benchmarks（基准测试）
+
+## 一、你将会在这一章学到什么？
+
+* 什么是benchmark？
+* 怎么写一个benchmark。
+* 怎么阅读benchmark的结果。
+
+## 二、技术概念涵盖
+
+* benchmark（基准测试）
+* solver（解决方案）
+* 内存分配（动态的和静态的）
+
+## 三、介绍
+
+一个问题可能会有不同的解决方案。
+
+让我们举个例子：你不小心弄丢了你的钥匙，但是你想打开自己家的门。这个问题有几个解决方案。你可以：
+
+1. 打电话给有共享钥匙的同伴
+
+2. 打电话给锁匠来开门
+
+3. 返回你弄丢钥匙的地方寻找钥匙。要是在三个小时之内没有找到，采取上面两种方案。
+
+4. 打碎玻璃进入房子
+
+这些解决方案都有同一个结果；你会打开房门。但是如果你稍微思考一下，您能够给这些方案按照花费时间排序。方案2和4将会花费你的金钱。方案3很有可能会花费你更多的时间。但是如果你只是将钥匙忘在了自己的车上，而停车场离你你只有五分钟路程远。显然在这种情况下，方案3将会比预期花费的少。
+
+通过在脑海里测试不同的可能性方案，你就是在进行benchmark（基准测试）
+
+## 四、什么是基准测试
+
+基准测试是用来比较系统和组件的工具。
+
+设计和运行基准测试的目的是找到最佳的解决策略。（也叫做solver）
+
+解决方案（solver）常常是一个方法。
+
+为了选择最佳的solver，需要制定一个规则。在基准测试中，程序执行的统计数字将会被收集起来（计算时间、affectation是什么？、函数调用次数等）。有了这些统计数字，我们能选择一个决策规则。
+
+这里并没有一个通用规则。规则可能会随着你的需求变化，比如，如果你想选择CPU占用更少的程序，你只用关心这些统计数字即可。如果你设计的程序运行在只有很少存储空间可用的设备上，你也许会更关注内存使用的统计数字来选择最佳方案（solver）。
+
+## 五、怎么写一个基准测试
+
+我们将比较两个将字符串连接起来的算法。第一步是创建两个函数分别使用这两种方案：
+
+```go
+//benchmark/basic/bench.go
+package basic
+
+import(
+	"bytes"
+  "strings"
+)
+
+func ConcatenateBuffer(first string,second string)string{
+  var buffer bytes.Buffer
+  buffer.WriteString(first)
+  buffer.WriteString(second)
+  return buffer.String()
+}
+
+func ConcatenateJoin(first string,second string)string{
+  return strings.Join([]string{first,second},"")
+}
+```
+
+连两个函数都实现了将两个字符串连接的功能。他们分别使用了不同的方法。第一个函数`ConcatenateBuffer`使用一个buffer（来自`buffer`包）。第二个函数将来自`strings`包的`Join`函数封装了一下。我们想知道这两种方式哪一种最好。
+
+benchmarks are living next to the unit tests。一个基准测试是在一个测试文件里的函数。它的名字必须以Benchmark开头。基准测试函数有着以下的结构：
+
+```go
+func BenchmarkXXX(b *testing.B){
+  
+}
+```
+
+这个函数有一个`testing.B`类型的指针。这个类型结构只有一个可导出的属性：`N`，表示需要跑的测试的数量（这里iteration还不确定怎么翻译）基准测试会对同一个函数跑好几次测试来收集可靠的数据。这是为什么基准测试函数总是含括这种循环：
+
+```go
+for i:=0;i<b.N;i++{
+  //在这里执行函数
+}
+```
+
+可以看到循环从0开始，到达`b.N`停止。不要自己声明值取代`b.N`。基准测试包会运行基准测试一次然后决定是否应该继续跑下去。`N`的值会根据是否到达了期待的可靠水平而调整（我们会在这章的后面深入讨论）让我们来看看我们的两个基准测试：
+
+```go
+//benchmark/basic/bench_test.go
+
+var result string
+func BenchmarkConcatenateBuffer(b *testing.B){
+  var s string
+  for i:=0;i<b.N;i++{
+    s = ConcatenateBuffer("test2","test3")
+  }
+  result = s
+}
+
+func BenchmarkConcatenateJoin(b *testing.B){
+  var s string
+  for i:=0;i<b.N;i++{
+    s = ConcatenateJoin("test2","test3")
+  }
+  result = s
+}
+```
+
+我们首先声明了一个`result`变量。这个变量在这里只是为了避免编译器优化（这是Dave Cheney在他的[Blog](https://dave.cheney.net/2013/06/30/how-to-write-benchmarks-in-go)中给出的小贴士）。我们将会把结果保存在这个变量里。
+
+接下来我们定义我们的两个基准测试函数`BenchmarkConcatenateBuffer`和`BenchmarkConcatenateJoin`。值得注意的是他们有非常相似的结构。字符串连接的结果存放在变量`s`中。接下来我们定义一个循环，在循环里面，我们执行想要基准测试的函数。
+
+参数是固定的。我们在相同的条件下测试功能。
+
+## 六、怎么运行一次基准测试
+
+要运行基准测试，我们使用相同的go测试命令：
+
+```shell
+$ go test -bench=.
+```
+
+命令会输出：
+
+```shell
+goos: darwin
+goarch: amd64
+pkg: go_book/benchmark
+BenchmarkConcatenateBuffer-8    20000000                98.9 ns/op
+BenchmarkConcatenateJoin-8      30000000                56.1 ns/op
+PASS
+ok      go_book/benchmark       3.833s
+```
+
+我们将会在下一节看到这些结果的解释。
+
+上面的命令会运行该包内的所有的基准测试。
+
+### 6.1 运行特定一个基准测试
+
+为了只运行ConcatenateBuffer函数的基准测试，你可以使用如下的命令：
+
+```shell
+$ go test -bench ConcatenateBuffer
+```
+
+上面的命令是该命令的速记：
+
+```shell
+$ go test -test.bench ConcatenateBuffer
+```
+
+### 6.2 在写代码的时候做基准测试（不需要命令行）
+
+testing包提供了公共的方法来运行一个基准测试。然我们来看一个例子：
+
+```go
+// benchmark/without-cli/main.go
+package main
+
+import (
+    "bytes"
+    "fmt"
+    "testing"
+)
+
+func main() {
+    res := testing.Benchmark(BenchmarkConcatenateBuffer)
+    fmt.Printf("Memory allocations : %d \n", res.MemAllocs)
+    fmt.Printf("Number of bytes allocated: %d \n", res.Bytes)
+    fmt.Printf("Number of run: %d \n", res.N)
+    fmt.Printf("Time taken: %s \n", res.T)
+}
+
+// ..
+func BenchmarkConcatenateBuffer(b *testing.B) {
+    //..
+}
+```
+
+函数`testing.Benchmark`等待有效的基准测试函数，换言之，类型`func(b *testing.B)`声明的变量。要记住在Go的函数类型中是一等公民，并且能够被传入其他函数中。
+
+基准测试函数返回BenchmarkResult类型的变量：
+
+```go
+// 标准库
+// src/testing/benchmark.go(v1.11.4)
+type BenchmarkResult struct{
+  	N         int           // 迭代的次数
+    T         time.Duration // 总时间开销
+    Bytes     int64         // 在一次迭代中处理的字节数
+    MemAllocs uint64        // The total number of memory allocations.（内存分布的总数？空间复杂度？）
+    MemBytes  uint64        // The total number of bytes allocated.（字节分布的总数？）
+
+}
+```
+
+## 七、基准测试的参数
+
+-cpu
+
+基准测试默认使用GOMARPROCS数量的处理器运行。为了有可靠的基准测试，我建议你控制处理器数量；它的值应该与目标机器的处理器数量一致。
+
+基准测试的命令行工具支持正则。它会加载正则匹配的基准测试函数。
+
+比如，下面这个命令：
+
+```shell
+$ go test -bench .
+```
+
+将会启动所有的基准测试
+
+```shell
+$ go test -bench Join
+```
+
+将会启动所有所有函数名中包含字符串`"Join"`的基准测试函数。在我们上面的例子中，`BenchmarkConcatenateJoin`将会被启动，但是`BenchmarkConcatenateBuffer`不会
+
+-benchtime
+
+该参数允许你控制你的基准测试的执行时间。需要你传入一个时间间隔字符串比如`"3s"`。系统将会解析时间间隔，并且以确定的一段时间执行基准测试。它意味着你可以增加/减少基准测试花费的时间。
+
+例子：让我们执行名为`BenchmarkConcatenateJoin`的基准测试5秒：
+
+```shell
+$ go test -bench BenchmarkConcatenateJoin -benchtime 5s
+
+goos: darwin
+goarch: amd64
+pkg: go_book/benchmark
+BenchmarkConcatenateJoin-8      100000000               56.9 ns/op
+PASS
+ok      go_book/benchmark       5.760s
+```
+
+
+
+-benchmem
+
+该参数将会展示内存分配的统计结果。这个参数接收布尔值；默认设置为false。添加进命令行来激活这个功能。
+
+```shell
+$ go test -bench . -benchmem
+goos: darwin
+goarch: amd64
+pkg: go_book/benchmark
+BenchmarkConcatenateBuffer-8    20000000               105 ns/op      128 B/op          2 allocs/op
+BenchmarkConcatenateJoin-8      30000000                60.2 ns/op      16 B/op          1 allocs/op
+PASS
+ok      go_book/benchmark       4.093s
+```
+
+我们可以注意到在基准测试的结果中新打印了两列。在下面的章节，我们将学习怎样阅读这样的结果。
+
+## 八、 怎么阅读基准测试的结果
+
+我发现基准测试的结果是很难阅读的。我们将看到每种统计数据，对于每个统计数据，我们会尝试提供可操作的建议。
+
+![Benchmark results output[fig:Benchmark-results-output]](https://www.practical-go-lessons.com/img/benchmark_results.d02152ba.png)
+
+基准测试输出的结果如上图。
+
+在上图中你可以看到如下命令的标准输出：
+
+```shell
+$ go test -bench . -benchmem
+```
+
+我们将运行当前软件包中所有的基准测试函数，并做内存信息统计。基准测试结果包含以下统计信息：
+
+* 基准测试结果的首个打印的元素是两个Go环境变量：`GOOS`和`GOARCH`。你已经知道他们是什么了，他们对于比较基准测试的结果是很有用的。
+* Duration（最后一个2.497s）：这是执行及注册时花费的总时间。
+* 迭代的次数（在第二列）：记住，在每个基准测试函数里面，都有一个for循环。这个值代表着为了获得统计数据而执行的循环次数。你可以使用-benchtime参数增加基准测试的总耗时来增加循环的次数。它并不是基准测试执行的总迭代次数。
+* 每次执行所花费的纳秒数（ns/op）（在第三列）：能够告诉你方案平均每执行一次需要的多快。在我们的例子中，`ConcatenateBuffer`函数平均执行一次耗时55.97纳秒。而`ConcatenateJoin`函数平均执行一次耗时33.63纳秒。最快的函数是`ConcatenateJoin`在我们基准测试的语境里。
+* 使用的核心数（跟在基准测试函数名后面）：基准测试的结果与运行的系统环境有关。所以知道使用了多少核心数去跑基准测试是很重要的。在我们的例子中，使用的8个核心数（明明图中是16个23333）。你可以通过参数-cpu在启动基准测试的时候来调整使用的核心数。默认使用可以使用的最大核心数。
+* 每次运行所分配的字节数（第四列）：如果你添加了-benchmen参数，就会显示这一列。它将会提供你的方案的内存消耗统计数据。如果你想要优化内存使用，应该关注这个统计数字。
+* 每次运行分配的次数（第五列）：从名字可以知道该统计数字的意思。是每次运行时内存分配的次数。在下面一节，我们将会看到怎么检测内存分配来优化代码。
+
+## 九、内存分配检测
+
+Go有一个调试模式允许你打印关于程序运行情况的众多有很高价值的信息。内存分配是理解程序怎么运行的重要变量。内存分配简单分为两种类型：
+
+* 静态：内存在程序一开始时就分配好了内存。在C中，这样的情况发生在当你创建一个全局变量，或者静态变量时。这种内存在程序运行结束时被释放。只会被分配一次。
+
+* 动态：在程序中，编译或启动程序时，所有的内容都未知。例如，程序的功能随着用户的输入而变化。想想一个用来做复杂数学计算操作，内存分配的需求由输入决定，并且会有巨大的差距（加法不需要使用大量的内存，但是10000的阶乘需要使用大量的内存）这就是为什么程序需要在运行时动态分配内存。
+
+我们将会关注动态内存分配。我们将会使用环境变量`GODEBUG`来输出我们的两个函数分配的内存。
+
+首先创建一个程序小样来调用两个函数。
+
+```go
+package main
+
+// imports
+
+func main(){
+  basic.ConcatenateBuffer("first","second")
+  basic.ConcatenateJoin("first","second")
+}
+```
+
+这两个函数在basic包中(go_book/benchmark/basic)。编译该程序：
+
+```shell
+$ go build -o allocDetect main.go
+```
+
+-o参数指定输出的二进制文件名称。
+
+接着我们可以设置变量`GODEBUG`并运行二进制文件：
+
+```shell
+$ GODEBUG=allocfreetrace=1 ./allocDetect &>>trace.log
+```
+
+GODEBUG是一个环境变量，接受键值对列表。在这里我们告诉go的运行时为每次内存分配和释放生成堆栈追踪。接着使用`&>>trace.log`将标准输出和标准错误输出重定向到文件trace.log。如果存在该文件，将会把日志信息追加到文件。如果没有，创建该文件。
+
+在trace.log中，记录了1034行文本，包含了堆栈追踪信息。怎么利用该信息？如果我们引用该文档，程序的每次内存分配都会生成一次堆栈追踪信息。
+
+可以使用cat和grep命令来寻找想要的信息：
+
+```shell
+$ cat trace.log | grep -n /path/to/the/package/basic/bench.go
+```
+
+使用cat打印文件中所有信息，grep正则匹配想要的信息，这里文件的路径需要使用你自己的路径。
+
+| 管道命令用来链接命令。第一个命令的输出将会作为第二个命令的输入。整个命令构成一个管道。
+
+接下来是我们的输出：
+
+```go
+988:    /path/to/the/package/basic/bench.go:9 +0x31 fp=0xc000044758 sp=0xc000044710 pc=0x1055c81
+1005:   /path/to/the/package/basic/bench.go:12 +0xca fp=0xc000044758 sp=0xc000044710 pc=0x1055d1a
+1028:   /path/to/the/package/basic/bench.go:16 +0x7e fp=0xc00008af58 sp=0xc00008aef0 pc=0x1055dde
+```
+
+添加参数-n 返回匹配到的字符串那一行的内容。我们在文件中发现了三次内存分配。在路径的旁边，是造成内存分配的代码位于的行数。
+
+接下来是分析你的代码，看看哪里做了内存分配，以及如何避免。在ConcatenateBuffer函数中，以下两行造成了内存分配：
+
+```go
+var buffer bytes.Buffer
+```
+
+创建变量buffer
+
+```go
+buffer.String()
+```
+
+调用String方法
+
+调试选项的完整清单在这里：
+
+https://golang.org/pkg/runtime/#hdr-Environment_Variables
+
+## 十、输入变量的基准测试
+
+在前面的小节中，我们设计的基准测试的参数都是一致的。这种方法足以用于大多数情况。但是你可能会需要了解参数变化时函数的行为。
+
+我们使用`testing`包中定义的方法`Run`。这个方法的接收器是`testing.B`类型的指针
+
+如果我们想深入分析，可以使用变长字符串测试我们的两个函数。我们使用2的幂的长度序列：
+
+* 2
+* 16
+* 128
+* 1024
+* 8192
+* 65536
+* 524288
+* 4194304
+* 16777216
+* 134217728
+
+第一步是将这些整数放入名为lengths的切片中：
+
+```go
+lengths := []int{2,16,128,1024,8192,65536,524288,4194304,16777216,134217728}
+```
+
+使用for循环迭代这些数字。在每次迭代中创建两个不同长度的字符串：
+
+```go
+for _,l :=range lengths{
+  first := generateRandomString(l)
+  second := generateRandomString(l)
+}
+```
+
+一旦生成了这两个字符串，就可以将它们作为参数传入基准测试函数。
+
+我们将会创建两个子基准测试。子基准测试使用Run方法声明。它们必须使用典型的基准测试函数声明。我们将封装好的函数命名为`"BenchmarkConcatenation"`
+
+```go
+// benchmark/variable-input/bench_test.go
+func BenchmarkConcatenation(b * testing.B){
+  var s string
+  lengths:=[]int{2,16,128,1024,8192,65536,524288,4194304,16777216,134217728}
+  for _,l:=range lengths{
+    first := generateRandomString(l)
+    second := generateRandomString(l)
+  }
+}
+```
+
+在循环里面，我们可以调用`b.Run`方法两次（`b.Run`将会创建子基准测试）。首先，我们对`ConcaenateJoin`函数做基准测试：
+
+```go
+b.Run(fmt.Sprintf("ConcatenateJoin-%d",l),func(b *testing.B){
+  for i := 0;i<b.N;i++{
+    s = ConcatenateBuffer(first,second)
+  }
+  result = s
+})
+```
+
+需要注意的是，run方法接受两个参数：
+
+* name，将会显示在基准测试结果中
+* 函数，表示子基准测试。只能接受一个指向testing.B变量的指针
+
+我们自定义了基准测试的名称。在其后面追加了`l`的值（l代表了两个随机长度字符串的长度）。自定义对于提高结果的可靠性是必要的。
+
+第二个参数是非常典型的基准测试函数：一个for循环从1迭代到b.N。在这里面，最终会调用基准测试的目标函数。我们保存函数的result来避免编译器优化。
+
+要运行这个基准测试，我们使用与前面相同的命令：
+
+```shell
+go test -bench BenchmarkConcatenation -benchmem
+goos: darwin
+goarch: amd64
+pkg: go_book/benchmark/variableInput
+BenchmarkConcatenation/ConcatenateJoin-2-8              30000000         51.2 ns/op             4 B/op          1 allocs/op
+BenchmarkConcatenation/ConcatenateBuffer-2-8            20000000         93.0 ns/op           116 B/op          2 allocs/op
+BenchmarkConcatenation/ConcatenateJoin-16-8             20000000         62.5 ns/op            32 B/op          1 allocs/op
+BenchmarkConcatenation/ConcatenateBuffer-16-8           20000000        103 ns/op             144 B/op          2 allocs/op
+//...
+ok      go_book/benchmark/variableInput 33.975s
+```
+
+这里只是一部分结果，我并没有粘贴所有的标准输出。
+
+我们可以使用这里的数据生成个图表来帮助理解基准测试结果。将这里的输出重定向到文件以作后续处理。
+
+```shell
+$ go test -bench BenchmarkConcatenation -benchmem &>> benchmarkConcatenation.log
+```
+
+随着字符串长度（log-lin plot）的变化，不同方法的执行时间（ns/op）。
+
+##### 10.0.0.1 对数尺度
+
+上面的图以log-lin plot展示了数据。log-lin plot是一种水平坐标和纵坐标都是对数尺度的图。你可能对这种形式的图不熟悉，如果熟悉的话，可以跳过这一节。
+
+对数被用来记录数据范围大的情况。比如我们的随机长度。
+
+在我们的情况。推荐使用对数刻度而不是线性刻度。
+
+##### 10.0.0.2 解析基准函数结果
+
+Go没有内置的工具生成上面的这种图。必须手动解析标准输出以拿到数据。下面是我使用的脚本：
+
+```go
+package main
+
+import(
+	"fmt"
+  "io/ioutil"
+  "regexp"
+)
+
+func main(){
+  b,err := ioutil.ReadFile("/path/to/benchmarkConcatenation.log")
+  if err != nil{
+    panic(err)
+  }
+  benchmarkResult := string(b)
+  regexBench := regexp.MustCompile(`([a-zA-Z]*)-(\d+)-.* (\d+\.?\d+?)[\t]ns.*[\t](\d+)[\t]B.* (\d+) allocs`)
+  matches := regexBench.FindAllStringSubmatch(benchmarkResult,-1)
+  fmt.Println("benchmarkedFunction,stringLen,nsPerOp,bytesPerOp,mallocs")
+  for _,m := range matches{
+    fmt.Printf("%s,%s,%s,%s,%s\n",m[1],m[2],m[3],m[4],m[5])
+  }
+}
+```
+
+我使用以下有着五个捕获组的正则表达式来获取基准测试数据：
+
+`([a-zA-Z]*)-(\d+)-.* (\d+\.?\d+?)[\t]ns.*[\t](\d+)[\t]B.* (\d+) allocs`
+
+在下面的图中，你可以看到对应的捕获组以高亮显示：
+
+* 第一组捕获基准测试函数名（存放在m[1]）
+* 第二组捕获字符串的长度（存放在m[2]）
+* 第三组捕获每次操作耗费的时间（单位ns）
+* 第四组捕获每次操作分配的字节
+* 第五组捕获每次操作内存分配的次数
+
+变量matches是二维字符串切片：`[][]string`。`matches[0]`表示第一次基准测试，`matches[0][1]`表示该次基准测试的名称。
+
+##### 10.0.0.3 一点建议
+
+* 关注时间变化(ns/op)和内存使用
+* 为你的目标选择有条理的变量
+* 在合适的情况下使用对数刻度的图
+
+## 十一、常见错误：b.N作为参数
+
+基准测试函数的耗时不应该随着b.N的增加而增加。你的函数输入不应该依赖b.N的数值。否则，你的基准测试结果将不会显著。
+
+比如：
+
+```go
+func BenchmarkConcatenateBuffer(b *testing.B){
+  var s string 
+  for i:=0;i<b.N;i++{
+    s = ConcatenateBuffer(generateRandomString(b.N),generateRandomString(b.N))
+  
+  }
+  result = s
+} 
+```
+
+这里我们修改了ConcatenateBuffer的输入。我们使用由generateRandomString函数生成的随机字符串。这个函数将会使用由math/rand包生成的伪随机字符串。
+
+让我们来看看结果：
+
+`BenchmarkConcatenateBuffer-8   30000        138583 ns/op      319600 B/op    8 allocs/op`
+
+最终的结果，操作次数只有30000次，平均每次操作使用138583纳秒。
+
+得到的结果和前面使用固定字符串的例子（100 ns/op）相差很大。
+
+
+
+## 十二、自测题
+
+### 12.1 问题
+
+1. 基准测试函数的标准函数签名是什么（名字和特征）？
+2. 基准测试函数放在源码的哪个地方？
+3. 运行一次特定的基准测试使用什么命令？
+4. 要展示内存使用统计数据需要添加什么参数？
+5. 是或否？单位为ns/op的统计数据是基准测试耗费的总时间
+6. 怎么创建一个可以传入变量的基准测试？
+
+### 12.2 回答
+
+1. `func BenchmarkNameHere(b *testing.B)`
+
+2. 就放置在单元测试的旁边
+
+3. 步骤：
+
+   1. 如果你的基准测试函数是：
+
+      `func BenchmarkConcatenateBuffer(b *testing.B)`
+
+   2. `go test -bench ConcatenateBuffer`
+
+   3. 这里接收的`ConcatenateBuffer`参数能接受正则表达式
+
+4. `-benchmem`
+
+5. 错误，是函数执行一次的平均时间
+
+6. 在基准测试函数中，借助b.Run来创建子基准测试
+
+## 十三、关键延伸
+
+* 设计和运行基准测试的目的是寻找最佳解决策略（叫做solver）
+
+* “最佳”应该是符合你的项目的最佳方案：
+
+  * 是要最快的解决方案
+  * 还是使用最小的内存
+  * 还是均衡两者
+
+* 要创建一个基准测试，使用以下函数签名：
+
+  `func BenchmarkNameHere(b *testing.B)`
+
+* 基准测试函数就写在单元测试文件中，比如以下的这个例子：
+
+  ```go
+  func BenchmarkConcatenateJoin(b *testing.B) {
+      var s string
+      for i := 0; i < b.N; i++ {
+          s = ConcatenateJoin("test2", "test3")
+      }
+      result = s
+  }
+  ```
+
+* 要运行该包中的所有的基准测试，使用命令：
+
+  `go test -bench=.`
+
+* 要运行确定的某一个基准测试：
+
+  `$ go test -bench ConcatenateBuffer`
+
+* 要展示内存统计数据，添加参数“benchmem”：
+
+  `go test -bench . -benchmem`
+
+* 内存统计数据包括：每次操作分配的字节数、每次操作内存分配的次数
+
+* 环境变量`GODEBUG`允许你调试程序的运行时（列出内存分配情况等）
+
+* 基准测试函数可以由子测试。这种实践是为了测试函数对于不同输入的情况：
+
+  ```go
+  func BenchmarkConcatenation(b *testing.B) {
+      var s string
+      lengths := []int{2, 16, 128, 1024, 8192, 65536, 524288, 4194304, 16777216, 134217728}
+      for _, l := range lengths {
+          first := generateRandomString(l)
+          second := generateRandomString(l)
+          b.Run(fmt.Sprintf("ConcatenateJoin-%d", l), func(b *testing.B) {
+              for i := 0; i < b.N; i++ {
+                  s = ConcatenateJoin(first, second)
+              }
+              result = s
+          })
+          b.Run(fmt.Sprintf("ConcatenateBuffer-%d", l), func(b *testing.B) {
+              for i := 0; i < b.N; i++ {
+                  s = ConcatenateBuffer(first, second)
+              }
+              result = s
+          })
+      }
+  }
+  ```
+
+  ## 参考文献
+
+  - [institute1990ieee] Electrical, Institute of, and Electronics Engineers. 1990. “IEEE Standard Glossary of Software Engineering Terminology: Approved September 28, 1990, IEEE Standards Board.” In. Inst. of Electrical; Electronics Engineers.
+
+
+
+
+
+
+
+
+
diff --git "a/chap-34-benchmarks/\347\277\273\350\257\221\344\270\255\351\201\207\345\210\260\347\232\204\351\227\256\351\242\230.md" "b/chap-34-benchmarks/\347\277\273\350\257\221\344\270\255\351\201\207\345\210\260\347\232\204\351\227\256\351\242\230.md"
new file mode 100644
index 0000000000000000000000000000000000000000..daf5a8bb572be8826d7eac501820823508c7e330
--- /dev/null
+++ "b/chap-34-benchmarks/\347\277\273\350\257\221\344\270\255\351\201\207\345\210\260\347\232\204\351\227\256\351\242\230.md"
@@ -0,0 +1,12 @@
+翻译中遇到的问题：
+
+1.    Bytes     **int64**         // Bytes processed in one iteration.    MemAllocs **uint64**        // The total number of memory allocations.    MemBytes  **uint64**        // The total number of bytes allocated. 
+
+   这三个是什么意思？
+
+2. 10节里面的图片没有下载下来
+
+3. log-lin plot
+
+4. 10.0.0.2的图
+