ch7: fix code format

ch7/ch7-01.md

@@ -8,6 +8,7 @@
 
 ``` go
 package fmt
+
 func Fprintf(w io.Writer, format string, args ...interface{}) (int, error)
 func Printf(format string, args ...interface{}) (int, error) {
 	return Fprintf(os.Stdout, format, args...)
@@ -26,6 +27,7 @@ Fprintf的前綴F表示文件(File)也表明格式化輸出結果應該被寫入
 
 ``` go
 package io
+
 // Writer is the interface that wraps the basic Write method.
 type Writer interface {
 	// Write writes len(p) bytes from p to the underlying data stream.
@@ -45,14 +47,16 @@ io.Writer類型定義了函數Fprintf和這個函數調用者之間的約定。
 
 讓我們通過一個新的類型來進行校驗，下面\*ByteCounter類型里的Write方法，僅僅在丟失寫向它的字節前統計它們的長度。(在這個+=賦值語句中，讓len(p)的類型和\*c的類型匹配的轉換是必須的。)
 
+<u><i>gopl.io/ch7/bytecounter</i></u>
 ```go
-// gopl.io/ch7/bytecounter
 type ByteCounter int
+
 func (c *ByteCounter) Write(p []byte) (int, error) {
 	*c += ByteCounter(len(p)) // convert int to ByteCounter
 	return len(p), nil
 }
 ```
+
 因爲*ByteCounter滿足io.Writer的約定，我們可以把它傳入Fprintf函數中；Fprintf函數執行字符串格式化的過程不會去關註ByteCounter正確的纍加結果的長度。
 
 ```go
@@ -69,6 +73,7 @@ fmt.Println(c) // "12", = len("hello, Dolly")
 
 ```go
 package fmt
+
 // The String method is used to print values passed
 // as an operand to any format that accepts a string
 // or to an unformatted printer such as Print.

ch7/ch7-02.md

@@ -1,4 +1,5 @@
 ## 7.2. 接口類型
+
 接口類型具體描述了一繫列方法的集合，一個實現了這些方法的具體類型是這個接口類型的實例。
 
 io.Writer類型是用的最廣泛的接口之一，因爲它提供了所有的類型寫入bytes的抽象，包括文件類型，內存緩衝區，網絡鏈接，HTTP客戶端，壓縮工具，哈希等等。io包中定義了很多其它有用的接口類型。Reader可以代表任意可以讀取bytes的類型，Closer可以是任意可以關閉的值，例如一個文件或是網絡鏈接。（到現在你可能註意到了很多Go語言中單方法接口的命名習慣）

ch7/ch7-03.md

@@ -1,4 +1,5 @@
 ## 7.3. 實現接口的條件
+
 一個類型如果擁有一個接口需要的所有方法，那麽這個類型就實現了這個接口。例如，\*os.File類型實現了io.Reader，Writer，Closer，和ReadWriter接口。\*bytes.Buffer實現了Reader，Writer，和ReadWriter這些接口，但是它沒有實現Closer接口因爲它不具有Close方法。Go的程序員經常會簡要的把一個具體的類型描述成一個特定的接口類型。舉個例子，\*bytes.Buffer是io.Writer；\*os.Files是io.ReadWriter。
 
 接口指定的規則非常簡單：表達一個類型屬於某個接口隻要這個類型實現這個接口。所以：

ch7/ch7-04.md

@@ -2,8 +2,8 @@
 
 在本章，我們會學到另一個標準的接口類型flag.Value是怎麽幫助命令行標記定義新的符號的。思考下面這個會休眠特定時間的程序：
 
+<u></i>gopl.io/ch7/sleep</i></u>
 ```go
-// gopl.io/ch7/sleep
 var period = flag.Duration("period", 1*time.Second, "sleep period")
 
 func main() {
@@ -51,8 +51,8 @@ String方法格式化標記的值用在命令行幫組消息中；這樣每一
 
 讓我們定義一個允許通過攝氏度或者華氏溫度變換的形式指定溫度的celsiusFlag類型。註意celsiusFlag內嵌了一個Celsius類型(§2.5)，因此不用實現本身就已經有String方法了。爲了實現flag.Value，我們隻需要定義Set方法：
 
+<u><i>gopl.io/ch7/tempconv</i></u>
 ```go
-// gopl.io/ch7/tempconv
 // *celsiusFlag satisfies the flag.Value interface.
 type celsiusFlag struct{ Celsius }
 
@@ -89,8 +89,8 @@ func CelsiusFlag(name string, value Celsius, usage string) *Celsius {
 
 現在我們可以開始在我們的程序中使用新的標記：
 
+<u><i>gopl.io/ch7/tempflag</i></u>
 ```go
-// gopl.io/ch7/tempflag
 var temp = tempconv.CelsiusFlag("temp", 20.0, "the temperature")
 
 func main() {

ch7/ch7-06.md

@@ -29,6 +29,7 @@ func (p StringSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 ```go
 sort.Sort(StringSlice(names))
 ```
+
 這個轉換得到一個相同長度，容量，和基於names數組的切片值；併且這個切片值的類型有三個排序需要的方法。
 
 對字符串切片的排序是很常用的需要，所以sort包提供了StringSlice類型，也提供了Strings函數能讓上面這些調用簡化成sort.Strings(names)。
@@ -39,8 +40,8 @@ sort.Sort(StringSlice(names))
 
 下面的變量tracks包好了一個播放列表。（One of the authors apologizes for the other author’s musical tastes.）每個元素都不是Track本身而是指向它的指針。盡管我們在下面的代碼中直接存儲Tracks也可以工作，sort函數會交換很多對元素，所以如果每個元素都是指針會更快而不是全部Track類型，指針是一個機器字碼長度而Track類型可能是八個或更多。
 
+<u><i>gopl.io/ch7/sorting</i></u>
 ```go
-//gopl.io/ch7/sorting
 type Track struct {
 	Title  string
 	Artist string
@@ -210,6 +211,7 @@ sort.Sort(sort.Reverse(sort.IntSlice(values)))
 fmt.Println(values)                     // "[4 3 1 1]"
 fmt.Println(sort.IntsAreSorted(values)) // "false"
 ```
+
 爲了使用方便，sort包爲[]int,[]string和[]float64的正常排序提供了特定版本的函數和類型。對於其他類型，例如[]int64或者[]uint，盡管路徑也很簡單，還是依賴我們自己實現。
 
 **練習 7.8：** 很多圖形界面提供了一個有狀態的多重排序表格插件：主要的排序鍵是最近一次點擊過列頭的列，第二個排序鍵是第二最近點擊過列頭的列，等等。定義一個sort.Interface的實現用在這樣的表格中。比較這個實現方式和重複使用sort.Stable來排序的方式。

ch7/ch7-07.md

@@ -2,8 +2,8 @@
 
 在第一章中，我們粗略的了解了怎麽用net/http包去實現網絡客戶端(§1.5)和服務器(§1.7)。在這個小節中，我們會對那些基於http.Handler接口的服務器API做更進一步的學習：
 
+<u><i>net/http</i></u>
 ```go
-net/http
 package http
 
 type Handler interface {
@@ -17,8 +17,8 @@ ListenAndServe函數需要一個例如“localhost:8000”的服務器地址，
 
 想象一個電子商務網站，爲了銷售它的數據庫將它物品的價格映射成美元。下面這個程序可能是能想到的最簡單的實現了。它將庫存清單模型化爲一個命名爲database的map類型，我們給這個類型一個ServeHttp方法，這樣它可以滿足http.Handler接口。這個handler會遍歷整個map併輸出物品信息。
 
+<u><i>gopl.io/ch7/http1</i></u>
 ```go
-gopl.io/ch7/http1
 func main() {
 	db := database{"shoes": 50, "socks": 5}
 	log.Fatal(http.ListenAndServe("localhost:8000", db))
@@ -55,8 +55,8 @@ socks: $5.00
 
 目前爲止，這個服務器不考慮URL隻能爲每個請求列出它全部的庫存清單。更眞實的服務器會定義多個不同的URL，每一個都會觸發一個不同的行爲。讓我們使用/list來調用已經存在的這個行爲併且增加另一個/price調用表明單個貨品的價格，像這樣/price?item=socks來指定一個請求參數。
 
+<u><i>gopl.io/ch7/http2</i></u>
 ```go
-gopl.io/ch7/http2
 func (db database) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 	switch req.URL.Path {
 	case "/list":
@@ -114,8 +114,8 @@ no such page: /help
 
 在下面的程序中，我們創建一個ServeMux併且使用它將URL和相應處理/list和/price操作的handler聯繫起來，這些操作邏輯都已經被分到不同的方法中。然後我門在調用ListenAndServe函數中使用ServeMux最爲主要的handler。
 
+<u><i>gopl.io/ch7/http3</i></u>
 ```go
-gopl.io/ch7/http3
 func main() {
 	db := database{"shoes": 50, "socks": 5}
 	mux := http.NewServeMux()
@@ -154,8 +154,8 @@ func(w http.ResponseWriter, req *http.Request)
 
 語句http.HandlerFunc(db.list)是一個轉換而非一個函數調用，因爲http.HandlerFunc是一個類型。它有如下的定義：
 
+<u><i>net/http</i></u>
 ```go
-net/http
 package http
 
 type HandlerFunc func(w ResponseWriter, r *Request)
@@ -169,8 +169,8 @@ HandlerFunc顯示了在Go語言接口機製中一些不同尋常的特點。這
 
 因爲handler通過這種方式註冊非常普遍，ServeMux有一個方便的HandleFunc方法，它幫我們簡化handler註冊代碼成這樣：
 
+<u><i>gopl.io/ch7/http3a</i></u>
 ```go
-gopl.io/ch7/http3a
 mux.HandleFunc("/list", db.list)
 mux.HandleFunc("/price", db.price)
 ```
@@ -181,8 +181,8 @@ mux.HandleFunc("/price", db.price)
 
 然後服務器的主函數可以簡化成：
 
+<u><i>gopl.io/ch7/http4</i></u>
 ```go
-gopl.io/ch7/http4
 func main() {
 	db := database{"shoes": 50, "socks": 5}
 	http.HandleFunc("/list", db.list)

ch7/ch7-09.md

@@ -17,8 +17,8 @@ pow(x, 3) + pow(y, 3)
 
 下面的五個具體類型表示了具體的表達式類型。Var類型表示對一個變量的引用。（我們很快會知道爲什麽它可以被輸出。）literal類型表示一個浮點型常量。unary和binary類型表示有一到兩個運算對象的運算符表達式，這些操作數可以是任意的Expr類型。call類型表示對一個函數的調用；我們限製它的fn字段隻能是pow，sin或者sqrt。
 
+<u><i>gopl.io/ch7/eval</i></u>
 ```go
-gopl.io/ch7/eval
 // A Var identifies a variable, e.g., x.
 type Var string
 
@@ -254,8 +254,8 @@ Check方法的參數是一個Var類型的集合，這個集合聚集從表達式
 
 這個ParseAndCheck函數混合了解析和檢査步驟的過程：
 
+<u><i>gopl.io/ch7/surface</i></u>
 ```go
-gopl.io/ch7/surface
 import "gopl.io/ch7/eval"
 
 func parseAndCheck(s string) (eval.Expr, error) {

ch7/ch7-11.md

@@ -1,5 +1,7 @@
 ## 7.11. 基於類型斷言區别錯誤類型
+
 思考在os包中文件操作返迴的錯誤集合。I/O可以因爲任何數量的原因失敗，但是有三種經常的錯誤必須進行不同的處理：文件已經存在（對於創建操作），找不到文件（對於讀取操作），和權限拒絶。os包中提供了這三個幫助函數來對給定的錯誤值表示的失敗進行分類：
+
 ```go
 package os
 
@@ -7,16 +9,20 @@ func IsExist(err error) bool
 func IsNotExist(err error) bool
 func IsPermission(err error) bool
 ```
+
 對這些判斷的一個缺乏經驗的實現可能會去檢査錯誤消息是否包含了特定的子字符串，
+
 ```go
 func IsNotExist(err error) bool {
 	// NOTE: not robust!
 	return strings.Contains(err.Error(), "file does not exist")
 }
 ```
+
 但是處理I/O錯誤的邏輯可能一個和另一個平台非常的不同，所以這種方案併不健壯併且對相同的失敗可能會報出各種不同的錯誤消息。在測試的過程中，通過檢査錯誤消息的子字符串來保證特定的函數以期望的方式失敗是非常有用的，但對於線上的代碼是不夠的。
 
 一個更可靠的方式是使用一個專門的類型來描述結構化的錯誤。os包中定義了一個PathError類型來描述在文件路徑操作中涉及到的失敗，像Open或者Delete操作,併且定義了一個叫LinkError的變體來描述涉及到兩個文件路徑的操作，像Symlink和Rename。這下面是os.PathError：
+
 ```go
 package os
 
@@ -31,7 +37,9 @@ func (e *PathError) Error() string {
 	return e.Op + " " + e.Path + ": " + e.Err.Error()
 }
 ```
+
 大多數調用方都不知道PathError併且通過調用錯誤本身的Error方法來統一處理所有的錯誤。盡管PathError的Error方法簡單地把這些字段連接起來生成錯誤消息，PathError的結構保護了內部的錯誤組件。調用方需要使用類型斷言來檢測錯誤的具體類型以便將一種失敗和另一種區分開；具體的類型比字符串可以提供更多的細節。
+
 ```go
 _, err := os.Open("/no/such/file")
 fmt.Println(err) // "open /no/such/file: No such file or directory"
@@ -39,7 +47,9 @@ fmt.Printf("%#v\n", err)
 // Output:
 // &os.PathError{Op:"open", Path:"/no/such/file", Err:0x2}
 ```
+
 這就是三個幫助函數是怎麽工作的。例如下面展示的IsNotExist，它會報出是否一個錯誤和syscall.ENOENT(§7.8)或者和有名的錯誤os.ErrNotExist相等(可以在§5.4.2中找到io.EOF）；或者是一個*PathError，它內部的錯誤是syscall.ENOENT和os.ErrNotExist其中之一。
+
 ```go
 import (
 	"errors"
@@ -58,9 +68,12 @@ func IsNotExist(err error) bool {
 	return err == syscall.ENOENT || err == ErrNotExist
 }
 ```
+
 下面這里是它的實際使用：
+
 ```go
 _, err := os.Open("/no/such/file")
 fmt.Println(os.IsNotExist(err)) // "true"
 ```
+
 如果錯誤消息結合成一個更大的字符串，當然PathError的結構就不再爲人所知，例如通過一個對fmt.Errorf函數的調用。區别錯誤通常必須在失敗操作後，錯誤傳迴調用者前進行。

ch7/ch7-14.md

@@ -4,8 +4,8 @@
 
 這里顯示的是和這個API相關的部分：
 
+<u><i>encoding/xml</i></u>
 ```go
-encoding/xml
 package xml
 
 type Name struct {
@@ -37,8 +37,8 @@ func (*Decoder) Token() (Token, error) // returns next Token in sequence
 
 下面的xmlselect程序獲取和打印在一個XML文檔樹中確定的元素下找到的文本。使用上面的API，它可以在輸入上一次完成它的工作而從來不要具體化這個文檔樹。
 
+<u><i>gopl.io/ch7/xmlselect</i></u>
 ```go
-gopl.io/ch7/xmlselect
 // Xmlselect prints the text of selected elements of an XML document.
 package main