作業系統

按照實驗要求，結合自己的電腦設備與系統等條件，使用VirtualBox下Ubuntu 20.04系統完成實驗，虛擬機相關設定與上一次實驗相同，

環境準備

虛擬機下的實驗環境與上一次實驗的相同，不需要額外的配置，

概念定義與理解

TDD的概念

TDD是測驗驅動開發(Test-Driven Development)的縮寫，

根據百度百科的定義：

TDD是測驗驅動開發（Test-Driven Development）的英文簡稱，是敏捷開發中的一項核心實踐和技術，也是一種設計方法論，TDD的原理是在開發功能代碼之前，先撰寫單元測驗用例代碼，測驗代碼確定需要撰寫什么產品代碼，TDD雖是敏捷方法的核心實踐，但不只適用于XP（Extreme Programming），同樣可以適用于其他開發方法和程序，

根據課程參考資料https://studygolang.gitbook.io中的指導，TDD程序的具體程序和特征如下：

• 撰寫一個失敗的測驗，并查看失敗資訊，我們知道現在有一個為需求撰寫的 相關 的測驗，并且看到它產生了 易于理解的失敗描述
• 撰寫最少量的代碼使其通過，以獲得可以運行的程式
• 然后 重構，基于我們測驗的安全性，以確保我們擁有易于使用的精心撰寫的代碼

通過基于TDD的軟體開發，可以更好地保障軟體質量，幫助更及時地發現功能模塊潛在的問題并修復，基于TDD的軟體開發也可以讓我們更好地積累對已經完成的功能模塊的信心，更好地聚焦于后續功能模塊的開發，在產品發布時，經過了嚴格測驗的功能模塊也能讓軟體出現問題的可能性降低，減小發布團隊的壓力，

重構的概念

在軟體開發領域，重構（Refactoring）就是通過調整程式代碼改善軟體的質量、性能，使其程式的設計模式和架構更趨合理，提高軟體的擴展性和維護性，

一個軟體總是為解決某種特定的需求而產生，時代在發展，客戶的業務也在發生變化，有的需求相對穩定一些，有的需求變化的比較劇烈，還有的需求已經消失了，或者轉化成了別的需求，在這種情況下，軟體必須相應的改變，

軟體在一次次面向客戶的需求經過了相應的改變后，軟體的結構可能發生了很大的變化，即使軟體最初剛制造出來的時候是經過精心設計并具有良好結構的，但經過了一次次面向客戶需求的修改，其可能面目全非且結構混亂，并且代碼耦合度增高且難以維護，

為了解決這樣的問題，就需要進行代碼重構，使用重構的方式，不改變系統的外部功能，只對內部的結構進行重新的整理，使得軟體的代碼耦合度降低，更加緊湊和模塊化，性能也可以得到提升，利于軟體之后的維護和繼續改進，

測驗的概念

在軟體開發領域，測驗指的是為了保證軟體的質量，對軟體的功能進行測驗，驗證是否能滿足設計需求，測驗是一種用來促進鑒定軟體的正確性、完整性、安全性和質量的程序，

通過周期性的對軟體進行測驗，可以評估軟體是否達到設計需求，方便及時修正彌補軟體的不足，并且保證了軟體的質量有利于后續對軟體專案的進一步開發，

基準測驗的概念

根據百度百科：

基準測驗是指通過設計科學的測驗方法、測驗工具和測驗系統，實作對一類測驗物件的某項性能指標進行定量的和可對比的測驗，

基準測驗常會呼叫被測驗的代碼/函式，通過運行若干次求平均值的方法，計算出這部分代碼/函式的運行平均性能，通過基準測驗，可以更好地了解軟體性能和吞吐能力，更好地評估軟體的運行效果，其也可以幫助在軟體的多個方案之間進行比較，確定更好的解決方案，對于性能沒有達到基準測驗要求的軟體，也可以根據其基準測驗的結果進行有針對性的改進，

通過TDD實踐完成“迭代”章節的練習

在 Go 中只能使用 for 來回圈和迭代，下面根據教程的相關章節一步步實踐練習Go的迭代陳述句，

Go中的for陳述句與C語言中的類似，但是for后面的初始化，回圈條件等三條陳述句沒有圓括號，且回圈體外面必須要加大括號，

先寫測驗

這一節的作業目錄在"$GOPATH/src/github.com/{your-user-id}/iteration"下

由于我的github的user id為alphabstc，這一節下面顯示的作業目錄就在"$GOPATH/src/github.com/alphabstc/iteration"之下，

首先為一個重復字符 5 次的函式撰寫測驗，在上述作業目錄下創建名為repeat_test.go的代碼檔案，在檔案中輸入下面的代碼：

package iteration

import "testing"

func TestRepeat(t *testing.T) {
    repeated := Repeat("a")
    expected := "aaaaa"

    if repeated != expected {
        t.Errorf("expected '%q' but got '%q'", expected, repeated)
    }
}

上面的測驗檢查Repeat(“a”)函式的回傳值是否為"aaaaa"，

嘗試運行測驗

在作業目錄下運行“go test”進行測驗，運行結果如下：

可以看到，和教程預期的結果一樣，由于目前包內還沒有定義Repeat函式，測驗的結果為沒有找到Repeat函式的定義，運行失敗，

先使用最少的代碼來讓失敗的測驗先跑起來

現在只需讓代碼可編譯，這樣就可以檢查測驗用例能否通過，

在包內，也就是之前所在的作業目錄下，創建名為repeat.go的代碼檔案，并且在其中輸入以下內容，完成package的宣告和Repeat函式的定義，

package iteration

func Repeat(character string) string {
    return ""
}

接著再次運行測驗：

可以看到與預期結果相同，現在定義了Repeat函式，但沒有具體實作其內容，因此現在可以通過編譯并測驗，由于還沒有實作好Repeat函式的功能，因此測驗結果是失敗的，

把代碼補充完整，使得它能夠通過測驗

接下來補充完整代碼使得可以通過上面的測驗，go語言也算是C語言族中的語言，for回圈陳述句語法與C語言的也比較類似，

下面修改repeat.go中之前定義的Repeat函式內容如下：

func Repeat(character string) string {
    var repeated string
    for i := 0; i < 5; i++ {
        repeated = repeated + character
    }
    return repeated
}

上面的函式使用for回圈迭代5次，每次將character累加到字串repeated上，使得repeated最后是5次重復的字串character，

與 C，Java 或 JavaScript等其他C語言族中的語言不同， Go 中的 for回圈 陳述句前導條件部分并沒有圓括號，而且回圈體外的大括號是必須的，

現在可以看到通過了測驗，也符合預期，

重構

上面的代碼通過了測驗，現在重構一下代碼，并檢查是否仍然能通過測驗，

現在將回圈次數作為常量定義，并且在累加字串的時候采用+=運算子而不是之前的+運算子，修改Repeat函式的代碼如下：

const repeatCount = 5

func Repeat(character string) string {
    var repeated string
    for i := 0; i < repeatCount; i++ {
        repeated += character
    }
    return repeated
}

可以看到，重構后的代碼仍然可以通過測驗，符合要求，說明了重構后代碼的正確性，

基準測驗

現在進一步在repeat_test.go中定義基準測驗函式的代碼如下：

func BenchmarkRepeat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Repeat("a")
    }
}

可以看到，基準測驗的函式定義和測驗的是類似的，

基準測驗運行時，Repeat會被呼叫 b.N 次，并測量需要多長時間，測驗框架會選擇一個它所認為的最佳值，以便獲得更合理的結果，

以上結果說明在我的電腦上運行一次這個函式需要288納秒，基準測驗呼叫了它運行了3814573次，

修改測驗代碼，以便呼叫者可以指定字符重復的次數，然后修復代碼

首先修改測驗代碼中的TestRepeat函式和BenchmarkRepeat函式，修改后的測驗代碼repeat_test.go呼叫Repeat會傳入兩個引數，一個為要被重復的字串，一個是重復次數，修改后的代碼如下：

func TestRepeat(t *testing.T) {
    repeated := Repeat("a", 5)
    expected := "aaaaa"

    if repeated != expected {
        t.Errorf("expected '%q' but got '%q'", expected, repeated)
    }
}
func BenchmarkRepeat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Repeat("a", 5)
    }
}

然后再次運行測驗，會提示如下的錯誤：

上面的錯誤資訊提示說，傳入Repeat的引數過多，根據提示，現在修復Repeat的代碼使其可以通過測驗，修改后的代碼如下：

func Repeat(character string, repeatCount int) string {
    var repeated string
    for i := 0; i < repeatCount; i++ {
        repeated += character
    }
    return repeated
}

再次運行測驗和基準測驗：

可以看到，現在可以正常運行測驗和基準測驗，上面的結果說明通過了測驗；且基準測驗測量出運行一次Repeat函式平均需要264ns，為了測量出平均用時，呼叫了Repeat函式4320328次，

這樣就實作了，可以指定重復次數的功能，

寫一個 ExampleRepeat 來完善你的函式檔案

Go 示例執行起來就像測驗一樣，示例反映出的是代碼的實際功能，作為包的測驗套件的一部分，示例會被編譯（并可選擇性地執行），與典型的測驗一樣，示例是存在于一個包的 _test.go 檔案中的函式，

因此，向repeat_test.go檔案添加ExampleRepeat函式如下：

func ExampleRepeat(){
    ans := Repeat("ab", 7)
	fmt.Println(ans)
	// Output: ababababababab
}

運行這個包的測驗套件(-v選項會顯示每個用例的測驗結果)，得到如下的結果：

可以看見，Repeat函式也通過了ExampleRepeat示例函式的測驗，

之后驗證檔案中會包含以上的內容：

首先，在終端中輸入并運行以下命令：

godoc -http=:6060

上面的命令運行了godoc服務端程式，并讓其監聽在6060埠，

之后打開瀏覽器，瀏覽http://localhost:6060/pkg/的網頁內容如下：

可以看到，該網址包含很多包的說明檔案，

之后找用戶撰寫的iteration包的檔案并點擊查看：

可以看到檔案中包括之前定義的Repeat函式的函式原型，以及示例函式ExampleRepeat的內容及運行結果，此時正確完成了ExampleRepeat函式并將其加入了示例檔案，

看一下 strings 包，找到你認為可能有用的函式，并對它們撰寫一些測驗，投入時間學習標準庫會慢慢得到回報，

在上一小節的網址中進一步查看 strings 包，發現里面非常多關于字串操作與處理的函式：


其中，strings中的index函式的原型和示例如下：

可以看到該函式可以求出一個字串在另一個字串中第一次出現的位置(不存在回傳-1)，

為Index函式撰寫如下的測驗：

func TestIndex(t *testing.T) {
    result := strings.Index("abcdabcab", "dabc")
    expected := 3

    if result != expected {
        t.Errorf("expected %d but got %d", expected, result)
    }
}

之后，再進行測驗：

可以看到通過了TestIndex函式的測驗，

通過TDD實踐完成歐幾里得(輾轉相除)演算法

歐幾里得(輾轉相除)演算法是求解兩個數最大公約數的經典數論演算法，其利用了如下的性質：
g c d ( a , b ) = g c d ( b , a m o d ?? b ) gcd(a,b)=gcd(b, a \mod b) gcd(a,b)=gcd(b,amodb)
根據上面的性質，反復使用該等式，就可以最終求出兩個數的gcd的值，

這一節的作業目錄在"$GOPATH/src/github.com/{your-user-id}/numberTheory"下

由于我的github的user id為alphabstc，這一節下面顯示的作業目錄就在"$GOPATH/src/github.com/alphabstc/numberTheory"之下，

先寫測驗

先撰寫對最大公約數求解結果的測驗，在上述作業目錄下創建名為gcd_test.go的代碼檔案，在檔案中輸入下面的代碼：

func TestGcd(t *testing.T) {
    res := Gcd(42, 48)
    expected := 6

    if res != expected {
        t.Errorf("expected %d but got %d", expected, res)
    }
}

上面的代碼檢查了Gcd(42,48)函式的回傳值是否為6，

嘗試運行測驗

在作業目錄下運行“go test”進行測驗，運行結果如下：

可以看到，由于目前包內還沒有定義Gcd函式，測驗的結果為沒有找到Gcd函式的定義，運行失敗，

先使用最少的代碼來讓失敗的測驗先跑起來

現在只需讓代碼可編譯，這樣就可以檢查測驗用例能否通過，

在包內，也就是之前所在的作業目錄下，創建名為gcd.go的代碼檔案，并且在其中輸入以下內容，完成package的宣告和gcd函式的定義，

package numberTheory

func Gcd(a int, b int) int {
    return 0
}

接著再次運行測驗：

可以看到，現在定義了Gcd函式，但沒有具體實作其內容，因此現在可以通過編譯并測驗，由于還沒有實作好Gcd函式的功能，因此測驗結果是失敗的，

把代碼補充完整，使得它能夠通過測驗

接下來補充完整代碼使得可以通過上面的測驗，go語言也算是C語言族中的語言，if條件分支陳述句語法與C語言的也比較類似，但與 C，Java 或 JavaScript等其他C語言族中的語言不同， Go 中的if條件分支陳述句前導條件部分并沒有圓括號，而且大括號是必須的，并且關鍵字 if 和 else 之后的左大括號{必須和關鍵字在同一行，如果使用了 else if 結構，則前段代碼塊的右大括號 } 必須和 else if 關鍵字在同一行，這兩條規則都是被編譯器強制規定的，

下面修改gcd.go中之前定義的Gcd函式內容如下：

func Gcd(a int, b int) int {
	if b == 0 {
		return a
	} 
	return Gcd(b, a % b)
}

修改后再次進行測驗：

現在可以看到通過了測驗，符合要求，

基準測驗

現在進一步在gcd_test.go中定義基準測驗函式的代碼如下：

func BenchmarkGcd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Gcd(42, 48)
    }
}

基準測驗運行時，Gcd會被呼叫 b.N 次，并測量需要多長時間，測驗框架會選擇一個它所認為的最佳值，以便獲得更合理的結果，

以上結果說明在我的電腦上運行一次這個函式平均需要42.4納秒，基準測驗呼叫了它運行了29394721次，

重構

上面的代碼通過了測驗，現在重構一下代碼，并檢查是否仍然能通過測驗，

之前的Gcd函式代碼是遞回版的，現在修改其為非遞回版的代碼如下：

func Gcd(a int, b int) int {
	var r int
	for ; b != 0; {
		r = a % b
		a = b
		b = r
	}
	return a
}

可以看到，重構后的代碼仍然可以通過測驗，符合要求，說明了重構后代碼的正確性，

再次運行基準測驗

以上結果說明在我的電腦上運行一次這個函式平均需要31.6納秒，基準測驗呼叫了它運行了35361135次，可見，采用非遞回版本的歐幾里得演算法代碼運行速度比遞回版代碼更快，在上面的基準測驗中平均用時減少了大約四分之一，

寫一個示例函式來完善函式檔案

繼續向gcd_test.go檔案添加ExampleGcd函式如下：

func ExampleGcd(){
    ans := Gcd(28, 70)
	fmt.Println(ans)
	// Output: 14
}

運行這個包的測驗套件(-v選項會顯示每個用例的測驗結果)，得到如下的結果：

可以看見，Gcd函式也通過了ExampleGcd示例函式的測驗，

之后看到，上面撰寫的示例函式也出現在了檔案中：

可以看到檔案中包括之前定義的Gcd函式的函式原型，以及示例函式ExampleGcd的內容及運行結果，此時正確完成了ExampleGcd函式并將其加入了示例檔案，

通過TDD實踐完成快速排序演算法

先寫測驗

快速排序演算法是一種空間復雜度為 O ( n ) O(n) O(n)，時間復雜度為 O ( n l o g n ) O(nlogn) O(nlogn)的排序演算法，其利用了分治和遞回的思想，將小于等于某個數的數都劃分到陣列的一邊，將大于某個數的數都劃分到陣列的另一邊，之后對兩邊分別遞回呼叫快速排序，這樣就完成了對一個陣列的排序程序，上面劃分操作的時間復雜度為 O ( n ) O(n) O(n)，則快速排序的時間復雜度 T ( n ) T(n) T(n)滿足 T ( n ) = T ( n 2 ) + O ( n ) T(n)=T(\frac{n}{2})+O(n) T(n)=T(2n?)+O(n)，根據主定理， T ( n ) = O ( n l o g n ) T(n)=O(nlogn) T(n)=O(nlogn)，

這一節的作業目錄在"$GOPATH/src/github.com/{your-user-id}/sort"下

由于我的github的user id為alphabstc，這一節下面顯示的作業目錄就在"$GOPATH/src/github.com/alphabstc/sort"之下，

先寫測驗

先撰寫對快速排序求解結果的測驗，在上述作業目錄下創建名為quicksort_test.go的代碼檔案，在檔案中輸入下面的代碼：

package sort

import "testing"

func TestQuicksort(t *testing.T) {
	res := Quicksort([]int{3, 5, 11, 17, 21, 23, 18, 17, 2, 14, 8, 1})
	expected := []int{1, 2, 3, 5, 8, 11, 14, 17, 17, 18, 21, 23}

	if len(res) != len(expected){
		t.Errorf("plength expected: %d, got: %d", len(expected), len(res))
	}

	for i := 0; i < len(expected); i++ {
		if res[i] != expected[i] {
			t.Errorf("position %d expected: %d, got: %d", i, expected[i], res[i])
		}
	}
}

上面的代碼檢查了對一個亂序陣列快速排序后的結果是否為單調不降的順序，

嘗試運行測驗

在作業目錄下運行“go test”進行測驗，運行結果如下：

可以看到，由于目前包內還沒有定義Quicksort函式，測驗的結果為沒有找到Quicksort函式的定義，運行失敗，

先使用最少的代碼來讓失敗的測驗先跑起來

現在只需讓代碼可編譯，這樣就可以檢查測驗用例能否通過，

在包內，也就是之前所在的作業目錄下，創建名為quicksort.go的代碼檔案，并且在其中輸入以下內容，完成package的宣告和Quicksort函式的定義，

package sort

func Quicksort(a []int) []int {
	return a
}

接著再次運行測驗：

以看到，現在定義了Quicksort函式，但沒有具體實作其排序功能，直接將傳入的陣列引數回傳，因此現在可以通過編譯并運行測驗，由于還沒有實作好Quicksort函式的功能，因此測驗結果是失敗的，

把代碼補充完整，使得它能夠通過測驗

接下來補充完整代碼使得可以通過上面的測驗，這里先修改成為冒泡排序使得可以通過測驗，修改Quicksort函式代碼如下：

func Quicksort(arg []int) []int {
	a := make([]int, len(arg))
	for i, v := range arg {
		a[i] = v
	}
	
	l := len(a)
	for i := 1; i < l; i++ {
		for j := 0; j + 1 < l; j++ {
			if a[j] > a[j + 1] {
				t := a[j]
				a[j] = a[j + 1]
				a[j + 1] = t
			}
		}
	}
	return a
}

修改后再次進行測驗：

現在可以看到通過了測驗，符合要求，說明測驗代碼是符合要求的，實作的冒泡排序演算法也正確，

基準測驗

現在進一步在quicksort_test.go中定義基準測驗函式的代碼如下：

func BenchmarkQuicksort(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Quicksort([]int{3, 5, 11, 17, 21, 23, 18, 17, 2, 14, 8, 1})
    }
}

基準測驗運行時，Quicksort會被呼叫 b.N 次，并測量需要多長時間，測驗框架會選擇一個它所認為的最佳值，以便獲得更合理的結果，

以上結果說明在我的電腦上運行一次這個函式平均需要127納秒，基準測驗呼叫了它運行了9174644次，

重構

上面的冒泡排序代碼通過了測驗，現在重構一下代碼，使用快速排序完成Quicksort函數，并檢查是否仍然能通過測驗，

修改quicksort.go的內容如下：

package sort

import (
	"math/rand"
	"time"
)

func Quicksort(arg []int) []int {
	a := make([]int, len(arg))
	for i, v := range arg {
		a[i] = v
	}

	rand.Seed(time.Now().UnixNano())
	
	myqsort(a, 0, len(a) - 1);
	return a
}

func myqsort(a []int, left int, right int) {
	if left >= right {
		return;
	}
	ra := rand.Intn(right - left + 1) + left
	te := a[ra]
	a[ra] = a[left]
	a[left] = te

	i := left + 1
	j := right
	for {
		for ; i <= right && a[i] < a[left]; {
			i++
		}
		for ; left <= j && a[j] > a[left]; {
			j--
		}
		if i >= j {
			break;
		}
		te = a[j]
		a[j] = a[i]
		a[i] = te
	}
	te = a[j]
	a[j] = a[left]
	a[left] = te
	myqsort(a, left, j - 1)
	myqsort(a, j + 1, right)
}

之后再次測驗：

可以看到，重構后的代碼仍然可以通過測驗，符合要求，說明了重構后代碼的正確性，

再次運行基準測驗

以上結果說明在我的電腦上運行一次這個函式平均需要10800納秒，基準測驗呼叫了它運行了112654次，其平均運行時間比之前的冒泡排序要長，這大概是因為快速排序使用了遞回，因此在運行時需要壓堆疊，出堆疊等操作，這會導致演算法時間常數的增大，另一方面，為了防止快速排序退化(對于特定的資料，快速排序可能會退化為 O ( n 2 ) O(n^2) O(n2)時間復雜度的)，上面的實作程序中使用了偽亂數等庫函式，計算偽亂數以及亂數種子初始化也是需要較長時間的，不過通過隨機化的處理，快速排序時間復雜度退化的概率將會大大降低，綜合上面兩方便因素，對于當前長度只有12的陣列的特定測驗，快速排序顯得比之前的冒泡排序稍慢，但當陣列的長度n趨向于很大時，快速排序的平均漸進時間復雜度為 O ( n l o g n ) O(nlogn) O(nlogn)，是會明顯好過漸進時間復雜度為 O ( n 2 ) O(n^2) O(n2)的冒泡排序的，

修改測驗代碼，以便呼叫者可以指定按順序或逆序排序，然后修復代碼

首先修改測驗代碼中的TestQuicksort函式和BenchmarkQuicksort函式，修改后的測驗代碼quicksort_test.go呼叫Repeat會傳入兩個引數，一個為要被排序的陣列，一個是布爾型別(為false時表示升序，為true時表示降序)，修改后的代碼如下：

package sort

import "testing"

func TestQuicksort(t *testing.T) {
	res := Quicksort([]int{3, 5, 11, 17, 21, 23, 18, 17, 2, 14, 8, 1}, false)
	expected := []int{1, 2, 3, 5, 8, 11, 14, 17, 17, 18, 21, 23}

	if len(res) != len(expected){
		t.Errorf("plength expected: %d, got: %d", len(expected), len(res))
	}

	for i := 0; i < len(expected); i++ {
		if res[i] != expected[i] {
			t.Errorf("position %d expected: %d, got: %d", i, expected[i], res[i])
		}
	}

	res = Quicksort([]int{3, 5, 11, 17, 21, 23, 18, 17, 2, 14, 8, 1}, true)
	expected = []int{23, 21, 18, 17, 17, 14, 11, 8, 5, 3, 2, 1}

	if len(res) != len(expected){
		t.Errorf("plength expected: %d, got: %d", len(expected), len(res))
	}

	for i := 0; i < len(expected); i++ {
		if res[i] != expected[i] {
			t.Errorf("position %d expected: %d, got: %d", i, expected[i], res[i])
		}
	}
}

func BenchmarkQuicksort(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Quicksort([]int{3, 5, 11, 17, 21, 23, 18, 17, 2, 14, 8, 1}, false)
    }
}

然后再次運行測驗，會提示如下的錯誤：

上面的錯誤資訊提示說，傳入Quicksort函式的引數過多，根據提示，現在修復Quicksort函式的代碼使其可以根據傳入的引數支持升序和降序排序，修改后的代碼如下：

func Quicksort(arg []int, rev bool) []int {
	a := make([]int, len(arg))
	for i, v := range arg {
		a[i] = v
	}

	rand.Seed(time.Now().UnixNano())
	
	myqsort(a, 0, len(a) - 1);
	if rev {
		le := len(a)
		for i:= 0; i + i < le; i++ {
			te := a[i]
			a[i] = a[le - i - 1]
			a[le - i - 1] = te
		}
	}
	return a
}

再次運行測驗和基準測驗：

可以看到，現在可以正常運行測驗和基準測驗，上面的結果說明通過了測驗；且基準測驗測量出運行一次Quicksort函式平均需要10605ns，為了測量出平均用時，呼叫了Quicksort函式105500次，

這樣就實作了，可以指定升序排序還是降序排序的功能，

寫一個示例函式來完善函式檔案

繼續向quicksort_test.go檔案添加ExampleQuicksort函式如下：

func ExampleQuicksort(){
    ans := Quicksort([]int{1, 3, 5, 3, 2, 4}, false)
	fmt.Println(ans)
	ans = Quicksort([]int{1, 3, 5, 3, 2, 4}, true)
	fmt.Println(ans)
	// Output: [1 2 3 3 4 5]
	//[5 4 3 3 2 1]
}

運行這個包的測驗套件(-v選項會顯示每個用例的測驗結果)，得到如下的結果：

可以看見，Quicksort函式也通過了ExampleQuicksort示例函式的測驗，

之后看到，上面撰寫的示例函式也出現在了檔案中：

可以看到檔案中包括之前定義的Quicksort函式的函式原型，以及示例函式ExampleQuicksort的內容及運行結果，此時正確完成了ExampleQuicksort函式并將其加入了示例檔案，

小結

TDD是測驗驅動開發(Test-Driven Development)的縮寫，通過這次實驗，我學習并熟悉了TDD，重構，測驗，基準測驗的概念，通過代碼實踐我進一步熟悉了go的if陳述句，for陳述句，函式定義，陣列宣告與傳遞引數等語法，我也在實踐中進一步熟悉了go中作業空間，包，測驗，基準測驗，示例函式的概念，并了解了如何撰寫這些內容，通過閱讀Go語言的教學指導以及通過TDD實踐完成教程“迭代”章節的練習，歐幾里得演算法，快速排序演算法，我也進一步熟悉了TDD的開發流程，更深刻體會到了測驗驅動開發理念的重要作用與意義，