作業系統

按照實驗要求，結合自己的電腦裝置與系統等條件，使用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實踐完成歐幾里得(輾轉相除)演演算法

歐幾里得(輾轉相除)演演算法是求解兩個數最大公約數的經典數論演演算法。其利用瞭如下的性質：
$$gcd(a,b)=gcd(b,a\mathrm{m}\mathrm{o}\mathrm{d}b)$$
根據上面的性質，反覆使用該等式，就可以最終求出兩個數的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(nlogn)$的排序演演算法。其利用了分治和遞迴的思想，將小於等於某個數的數都劃分到陣列的一邊，將大於某個數的數都劃分到陣列的另一邊。之後對兩邊分別遞迴呼叫快速排序。這樣就完成了對一個陣列的排序過程。上面劃分操作的時間複雜度為$O(n)$，則快速排序的時間複雜度$T(n)$滿足$T(n)=T(\frac{n}{2})+O(n)$，根據主定理，$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)$時間複雜度的)，上面的實現過程中使用了偽亂數等庫函數，計算偽亂數以及亂數種子初始化也是需要較長時間的，不過通過隨機化的處理，快速排序時間複雜度退化的概率將會大大降低。綜合上面兩方便因素，對於當前長度只有12的陣列的特定測試，快速排序顯得比之前的氣泡排序稍慢。但當陣列的長度n趨向於很大時，快速排序的平均漸進時間複雜度為$O(nlogn)$，是會明顯好過漸進時間複雜度為$O(n^2)$的氣泡排序的。

修改測試程式碼，以便呼叫者可以指定按順序或逆序排序，然後修復程式碼

首先修改測試程式碼中的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的開發流程，更深刻體會到了測試驅動開發理念的重要作用與意義。