diff --git a/docs/golang_tutorial_09 - 副本 - 副本.md b/docs/golang_tutorial_09 - 副本 - 副本.md
new file mode 100644
index 0000000..dba1121
--- /dev/null
+++ b/docs/golang_tutorial_09 - 副本 - 副本.md	
@@ -0,0 +1,205 @@
+9 - 循环语句  
+========================
+
+上一节：[第八篇 if else 语句](/docs/golang_tutorial_08.md)   
+下一节：[第十篇 包](/docs/golang_tutorial_10.md)  
+
+这是本Golang系列教程的第9篇。  
+
+循环语句用于重复执行一段代码。  
+
+for 语句是 Go 中唯一的循环语句。Go 没有提供其他语言（如 C）中的 while 和 do while 语句。  
+
+## for 语句语法  
+
+for 语句的语法如下：  
+
+```golang
+for initialisation; condition; post {  
+}
+```
+
+其中， `initialisation` 为初始化语句，该语句仅执行一次。`initialisation` 语句结束后，接着对 `condition` 求值，如果 `condition` 求值结果为 `true`，则执行大括号` {} `里面的循环体，然后执行 post 语句，如果 `condition` 求值结果为 false 则退出循环。`post` 语句会在每次循环体执行结束后执行。执行完 `post` 语句之后，`condition` 会被重新求值，如果是`true`，则继续执行循环体，否则退出循环。  
+
+## 例子  
+
+下面的程序使用 for 循环打印 1 到 10 之间的整数。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    for i := 1; i <= 10; i++ {
+        fmt.Printf(" %d",i)
+    }
+}
+```
+
+在上面的程序中，`i` 被初始化为 `1`。条件语句判断` i `是否小于等于 `10`，如果是则打印 `i`，否则结束循环。`post` 语句在每次迭代结束时将 `i`递增 `1`。直到`i`的值大于 `10` 循环结束。  
+
+上面的程序打印：`1 2 3 4 5 6 7 8 9 10`  
+
+在 `for` 头部定义的变量仅在 `for` 语句范围内可见，因此 `i `不能在 `for` 循环体外被访问。  
+
+## break  
+
+`break` 语句用于终止 `for` 循环，继续执行 `for` 循环后面的语句。  
+
+下面的程序打印 1 到 5 之间的整数。请注意该程序中 `break` 的用法。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    for i := 1; i <= 10; i++ {
+        if i > 5 {
+            break //loop is terminated if i > 5
+        }
+        fmt.Printf("%d ", i)
+    }
+    fmt.Printf("\nline after for loop")
+}
+```
+
+在上面的程序中，每次迭代都会检查`i`的值，如果`i`大于 5 则执行 `break` 语句跳出循环，并执行 for 循环后面的那条 fmt.Printf 语句。上面的程序输出如下：  
+
+```golang
+1 2 3 4 5  
+line after for loop  
+```
+
+## continue  
+
+`continue` 语句用于跳过 `for` 循环的当前迭代。循环体中`continue`语句之后的所有语句将被跳过不予执行。循环将继续执行下一次迭代。  
+
+让我们写一个程序利用 `continue` 来打印 `1` 到 `10` 之间的奇数。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    for i := 1; i <= 10; i++ {
+        if i%2 == 0 {
+            continue
+        }
+        fmt.Printf("%d ", i)
+    }
+}
+```
+
+在上面的程序中，`if i%2 == 0`检测 `i` 除以 `2` 的余数是否为 `0`，如果为 `0` 则 `i` 是偶数，利用 `continue` 语句跳过当前迭代并继续下一次迭代。因此 `continue` 语句之后的 `fmt.Printf` 语句将不被执行，并且循环进入到下一次迭代。上面的程序输出为：`1 3 5 7 9`。  
+
+## 更多例子  
+
+让我们再写一些代码来演示 for 循环的其它变体。  
+
+下面的程序 打印 0 到 10 之间的所有偶数。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    i := 0
+    for ;i <= 10; { // initialisation and post are omitted
+        fmt.Printf("%d ", i)
+        i += 2
+    }
+}
+```
+
+我们已经知道 `for` 循环头部的三个部分`initialisation`，`condition`，`post` 都是可选的。上面的程序中，忽略了 `initialisation` 和 `post` 部分。`i` 在 `for` 循环之外初始化为 `0`，只要`i <= 10` 循环就一直执行，`i` 在循环体内每次递增 `2`。上面的程序输出为：`0 2 4 6 8 10`。  
+
+上面程序中的分号（`;`）也可以省略。这种形式的 `for` 循环可以视为 `while` 循环的替代品。上面的程序可以被重写如下：   
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    i := 0
+    for i <= 10 { //semicolons are ommitted and only condition is present
+        fmt.Printf("%d ", i)
+        i += 2
+    }
+}
+```
+
+可以在 `for` 循环中声明和操作多个变量，比如下面的程序：  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    for no, i := 10, 1; i <= 10 && no <= 19; i, no = i+1, no+1 { //multiple initialisation and increment
+        fmt.Printf("%d * %d = %d\n", no, i, no*i)
+    }
+
+}
+```
+
+上面的程序中，`no` 和` i `被声明并初始化为 `10` 和 `1`。它们在每次迭代结束时递增 `1`。在 `condition` 部分使用 `&&` 操作符来确保 `i` 小于或等于 `10` 并且 `no` 小于或等于 `19`。程序的输出如下：  
+
+```golang
+10 * 1 = 10  
+11 * 2 = 22  
+12 * 3 = 36  
+13 * 4 = 52  
+14 * 5 = 70  
+15 * 6 = 90  
+16 * 7 = 112  
+17 * 8 = 136  
+18 * 9 = 162  
+19 * 10 = 190 
+```
+
+## 无限循环  
+
+可以用下面的语法实现无限循环：  
+
+```golang
+for {  
+}
+```
+
+下面的程序将一直打印` Hello World `永不终止。  
+
+```golang
+package main
+
+import "fmt"
+
+func main() {  
+    for {
+        fmt.Println("Hello World")
+    }
+}
+```
+
+如果你在 [go playground ](https://play.golang.org/p/kYQZw1AWT4)执行上面的程序，你将得到一个错误：`process took too long`。请尝试在本地系统中运行它以无限打印`"Hello World"`。  
+
+还有一个` range for `可用于遍历数组，我们将在介绍数组时介绍它。  
+
+希望你喜欢阅读。请留下宝贵的意见和反馈:)  
\ No newline at end of file
diff --git a/docs/golang_tutorial_10.md b/docs/golang_tutorial_10.md
new file mode 100644
index 0000000..18fc6ca
--- /dev/null
+++ b/docs/golang_tutorial_10.md
@@ -0,0 +1,194 @@
+10 - switch 语句  
+========================
+
+上一节：[第九篇 循环语句](/docs/golang_tutorial_09.md)   
+下一节：[第十一篇 数组和切片](/docs/golang_tutorial_11.md)  
+
+这是本Golang系列教程的第10篇。  
+
+switch 是一个条件语句，用于将一个表达式的求值结果与可能的值的列表进行匹配，并根据匹配结果执行相应的代码。可以认为 `switch` 语句是编写多个 `if-else `子句的替代方式。  
+
+举例是说明问题最好的方式，让我们写一个简单的程序，输入手指编号，输出对应的手指称：）。例如 0 表示拇指，1 表示食指等。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    finger := 4
+    switch finger {
+    case 1:
+        fmt.Println("Thumb")
+    case 2:
+        fmt.Println("Index")
+    case 3:
+        fmt.Println("Middle")
+    case 4:
+        fmt.Println("Ring")
+    case 5:
+        fmt.Println("Pinky")
+    }
+}
+```
+
+在上面的程序中，case 语句依次（从上到下）求值并与 `finger` 进行匹配，直到找到第一个与 `finger` 匹配的 case，并执行其中的代码。在这里 `finger` 的值为 4，因此打印 `Ring`。  
+
+多个有相同值的 case 是不允许的。如果你运行下面的程序，编译将会报错：`duplicate case 4 in switch`。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    finger := 4
+    switch finger {
+    case 1:
+        fmt.Println("Thumb")
+    case 2:
+        fmt.Println("Index")
+    case 3:
+        fmt.Println("Middle")
+    case 4:
+        fmt.Println("Ring")
+    case 4://duplicate case
+        fmt.Println("Another Ring")
+    case 5:
+        fmt.Println("Pinky")
+    }
+}
+```
+
+## default case  
+
+我们每只手只有 5 根手指，但是如果我们输入一个错误的手指序号会发生什么呢？这里就要用到 `default` 语句了。当没有其他 case 匹配时，将执行 default 语句。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    switch finger := 8; finger {//finger is declared in switch
+    case 1:
+        fmt.Println("Thumb")
+    case 2:
+        fmt.Println("Index")
+    case 3:
+        fmt.Println("Middle")
+    case 4:
+        fmt.Println("Ring")
+    case 5:
+        fmt.Println("Pinky")
+    default: //default case
+        fmt.Println("incorrect finger number")
+    }
+}
+```
+
+在上面的程序中，`finger` 的值为 8，它不匹配任何 case，因此打印 `incorrect finger number`。default 语句不必放在 switch 语句的最后，而可以放在 switch 语句的任何位置。  
+
+你也许发现了另外一个小的改变，就是将 finger 声明在了 switch 语句中。switch 语句可以包含一个可选的语句，该语句在表达式求值之前执行。在` switch finger := 8`; `finger` 这一行中， `finger` 首先被声明，然后作为表达式被求值。这种方式（译者注：在 switch 语句中声明变量的方式）声明的 finger 只能在 switch 语句中访问。  
+
+## 包含多个表达式的 case  
+
+可以在一个 case 中包含多个表达式，每个表达式用逗号分隔。  
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    letter := "i"
+    switch letter {
+    case "a", "e", "i", "o", "u": //multiple expressions in case
+        fmt.Println("vowel")
+    default:
+        fmt.Println("not a vowel")
+    }
+}
+```
+
+上面的程序检测 letter 是否是元音。`case "a", "e", "i", "o", "u":` 这一行匹配所有的元音。程序的输出为：`vowel`。  
+
+## 没有表达式的 switch  
+
+switch 中的表达式是可选的，可以省略。如果省略表达式，则相当于` switch true`，这种情况下会将对每一个 case 的表达式的求值结果与 true 做比较，如果相等，则执行相应的代码。   
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func main() {  
+    num := 75
+    switch { // expression is omitted
+    case num >= 0 && num <= 50:
+        fmt.Println("num is greater than 0 and less than 50")
+    case num >= 51 && num <= 100:
+        fmt.Println("num is greater than 51 and less than 100")
+    case num >= 101:
+        fmt.Println("num is greater than 100")
+    }
+}
+```
+
+在上面的程序中，switch 后面没有表达式因此被认为是` switch true `并对每一个 case 表达式的求值结果与 true 做比较。`case num >= 51 && num <= 100:` 的求值结果为 `true`，因此程序输出：`num is greater than 51 and less than 100`。这种类型的 switch 语句可以替代多重 if else 子句。   
+
+## fallthrough  
+
+在 Go 中执行完一个 case 之后会立即退出 switch 语句。`fallthrough`语句用于标明执行完当前 case 语句之后按顺序执行下一个case 语句。  
+
+让我们写一个程序来了解 `fallthrough`。下面的程序检测 `number` 是否小于 50、100 或 200。列如：如果我们输入75，程序将打印 75 小于 100 和 200，这是通过 `fallthrough` 语句实现的。   
+
+```golang
+package main
+
+import (  
+    "fmt"
+)
+
+func number() int {  
+        num := 15 * 5 
+        return num
+}
+
+func main() {
+
+    switch num := number(); { //num is not a constant
+    case num < 50:
+        fmt.Printf("%d is lesser than 50\n", num)
+        fallthrough
+    case num < 100:
+        fmt.Printf("%d is lesser than 100\n", num)
+        fallthrough
+    case num < 200:
+        fmt.Printf("%d is lesser than 200", num)
+    }
+}
+```
+
+switch 与 case 中的表达式不必是常量，他们也可以在运行时被求值。在上面的程序中 num 初始化为函数 number() 的返回值。程序首先对 switch 中的表达式求值，然后依次对每一个case 中的表达式求值并与 true 做匹配。匹配到 `case num < 100:` 时结果是 true，因此程序打印：`75 is lesser than 100`，接着程序遇到 `fallthrough` 语句，因此继续对下一个 case 中的表达式求值并与 true 做匹配，结果仍然是 true，因此打印：`75 is lesser than 200`。最后的输出如下：   
+
+```golang
+75 is lesser than 100  
+75 is lesser than 200 
+```
+
+`fallthrough` 必须是 case 语句块中的最后一条语句。如果它出现在语句块的中间，编译器将会报错：`fallthrough statement out of place`。  
+
+还有一种 switch 语句叫做 `type switch`，我们将在学习接口时介绍它。  
+
+希望你喜欢阅读。请留下宝贵的意见和反馈:)  
\ No newline at end of file