From a91355f5f1f24443c47ac7ab2d99cf12d99c84d9 Mon Sep 17 00:00:00 2001 From: chai2010 Date: Mon, 18 Jan 2016 10:52:21 +0800 Subject: [PATCH] fmt code --- ch7/ch7-07.md | 108 ++++++++++---------- ch7/ch7-08.md | 18 ++-- ch7/ch7-09.md | 266 +++++++++++++++++++++++++------------------------- ch7/ch7-10.md | 16 ++- 4 files changed, 210 insertions(+), 198 deletions(-) diff --git a/ch7/ch7-07.md b/ch7/ch7-07.md index a21d5ff..ad02948 100644 --- a/ch7/ch7-07.md +++ b/ch7/ch7-07.md @@ -3,11 +3,11 @@ 在第一章中，我們粗略的了解了怎麽用net/http包去實現網絡客戶端(§1.5)和服務器(§1.7)。在這個小節中，我們會對那些基於http.Handler接口的服務器API做更進一步的學習： ```go -// net/http +net/http package http type Handler interface { - ServeHTTP(w ResponseWriter, r *Request) + ServeHTTP(w ResponseWriter, r *Request) } func ListenAndServe(address string, h Handler) error @@ -18,10 +18,10 @@ ListenAndServe函數需要一個例如“localhost:8000”的服務器地址， 想象一個電子商務網站，爲了銷售它的數據庫將它物品的價格映射成美元。下面這個程序可能是能想到的最簡單的實現了。它將庫存清單模型化爲一個命名爲database的map類型，我們給這個類型一個ServeHttp方法，這樣它可以滿足http.Handler接口。這個handler會遍歷整個map併輸出物品信息。 ```go -// gopl.io/ch7/http1 +gopl.io/ch7/http1 func main() { - db := database{"shoes": 50, "socks": 5} - log.Fatal(http.ListenAndServe("localhost:8000", db)) + db := database{"shoes": 50, "socks": 5} + log.Fatal(http.ListenAndServe("localhost:8000", db)) } type dollars float32 @@ -31,9 +31,9 @@ func (d dollars) String() string { return fmt.Sprintf("$%.2f", d) } type database map[string]dollars func (db database) ServeHTTP(w http.ResponseWriter, req *http.Request) { - for item, price := range db { - fmt.Fprintf(w, "%s: %s\n", item, price) - } + for item, price := range db { + fmt.Fprintf(w, "%s: %s\n", item, price) + } } ``` @@ -56,26 +56,26 @@ socks: $5.00 目前爲止，這個服務器不考慮URL隻能爲每個請求列出它全部的庫存清單。更眞實的服務器會定義多個不同的URL，每一個都會觸發一個不同的行爲。讓我們使用/list來調用已經存在的這個行爲併且增加另一個/price調用表明單個貨品的價格，像這樣/price?item=socks來指定一個請求參數。 ```go -// gopl.io/ch7/http2 +gopl.io/ch7/http2 func (db database) ServeHTTP(w http.ResponseWriter, req *http.Request) { - switch req.URL.Path { - case "/list": - for item, price := range db { - fmt.Fprintf(w, "%s: %s\n", item, price) - } - case "/price": - item := req.URL.Query().Get("item") - price, ok := db[item] - if !ok { - w.WriteHeader(http.StatusNotFound) // 404 - fmt.Fprintf(w, "no such item: %q\n", item) - return - } - fmt.Fprintf(w, "%s\n", price) - default: - w.WriteHeader(http.StatusNotFound) // 404 - fmt.Fprintf(w, "no such page: %s\n", req.URL) - } + switch req.URL.Path { + case "/list": + for item, price := range db { + fmt.Fprintf(w, "%s: %s\n", item, price) + } + case "/price": + item := req.URL.Query().Get("item") + price, ok := db[item] + if !ok { + w.WriteHeader(http.StatusNotFound) // 404 + fmt.Fprintf(w, "no such item: %q\n", item) + return + } + fmt.Fprintf(w, "%s\n", price) + default: + w.WriteHeader(http.StatusNotFound) // 404 + fmt.Fprintf(w, "no such page: %s\n", req.URL) + } } ``` @@ -115,32 +115,32 @@ no such page: /help 在下面的程序中，我們創建一個ServeMux併且使用它將URL和相應處理/list和/price操作的handler聯繫起來，這些操作邏輯都已經被分到不同的方法中。然後我門在調用ListenAndServe函數中使用ServeMux最爲主要的handler。 ```go -// gopl.io/ch7/http3 +gopl.io/ch7/http3 func main() { - db := database{"shoes": 50, "socks": 5} - mux := http.NewServeMux() - mux.Handle("/list", http.HandlerFunc(db.list)) - mux.Handle("/price", http.HandlerFunc(db.price)) - log.Fatal(http.ListenAndServe("localhost:8000", mux)) + db := database{"shoes": 50, "socks": 5} + mux := http.NewServeMux() + mux.Handle("/list", http.HandlerFunc(db.list)) + mux.Handle("/price", http.HandlerFunc(db.price)) + log.Fatal(http.ListenAndServe("localhost:8000", mux)) } type database map[string]dollars func (db database) list(w http.ResponseWriter, req *http.Request) { - for item, price := range db { - fmt.Fprintf(w, "%s: %s\n", item, price) - } + for item, price := range db { + fmt.Fprintf(w, "%s: %s\n", item, price) + } } func (db database) price(w http.ResponseWriter, req *http.Request) { - item := req.URL.Query().Get("item") - price, ok := db[item] - if !ok { - w.WriteHeader(http.StatusNotFound) // 404 - fmt.Fprintf(w, "no such item: %q\n", item) - return - } - fmt.Fprintf(w, "%s\n", price) + item := req.URL.Query().Get("item") + price, ok := db[item] + if !ok { + w.WriteHeader(http.StatusNotFound) // 404 + fmt.Fprintf(w, "no such item: %q\n", item) + return + } + fmt.Fprintf(w, "%s\n", price) } ``` @@ -155,13 +155,13 @@ func(w http.ResponseWriter, req *http.Request) 語句http.HandlerFunc(db.list)是一個轉換而非一個函數調用，因爲http.HandlerFunc是一個類型。它有如下的定義： ```go -// net/http +net/http package http type HandlerFunc func(w ResponseWriter, r *Request) func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) { - f(w, r) + f(w, r) } ``` @@ -170,7 +170,7 @@ HandlerFunc顯示了在Go語言接口機製中一些不同尋常的特點。這 因爲handler通過這種方式註冊非常普遍，ServeMux有一個方便的HandleFunc方法，它幫我們簡化handler註冊代碼成這樣： ```go -// gopl.io/ch7/http3a +gopl.io/ch7/http3a mux.HandleFunc("/list", db.list) mux.HandleFunc("/price", db.price) ``` @@ -182,17 +182,17 @@ mux.HandleFunc("/price", db.price) 然後服務器的主函數可以簡化成： ```go -// gopl.io/ch7/http4 +gopl.io/ch7/http4 func main() { - db := database{"shoes": 50, "socks": 5} - http.HandleFunc("/list", db.list) - http.HandleFunc("/price", db.price) - log.Fatal(http.ListenAndServe("localhost:8000", nil)) + db := database{"shoes": 50, "socks": 5} + http.HandleFunc("/list", db.list) + http.HandleFunc("/price", db.price) + log.Fatal(http.ListenAndServe("localhost:8000", nil)) } ``` 最後，一個重要的提示：就像我們在1.7節中提到的，web服務器在一個新的協程中調用每一個handler，所以當handler獲取其它協程或者這個handler本身的其它請求也可以訪問的變量時一定要使用預防措施比如鎖機製。我們後面的兩章中講到併發相關的知識。 -練習 7.11：增加額外的handler讓客服端可以創建，讀取，更新和刪除數據庫記録。例如，一個形如/update?item=socks&price=6的請求會更新庫存清單里一個貨品的價格併且當這個貨品不存在或價格無效時返迴一個錯誤值。（註意：這個脩改會引入變量同時更新的問題） +**練習 7.11：** 增加額外的handler讓客服端可以創建，讀取，更新和刪除數據庫記録。例如，一個形如/update?item=socks&price=6的請求會更新庫存清單里一個貨品的價格併且當這個貨品不存在或價格無效時返迴一個錯誤值。（註意：這個脩改會引入變量同時更新的問題） -練習 7.12：脩改/list的handler讓它把輸出打印成一個HTML的表格而不是文本。html/template包(§4.6)可能會對你有幫助。 +**練習 7.12：** 脩改/list的handler讓它把輸出打印成一個HTML的表格而不是文本。html/template包(§4.6)可能會對你有幫助。 diff --git a/ch7/ch7-08.md b/ch7/ch7-08.md index 0971ab2..99772d8 100644 --- a/ch7/ch7-08.md +++ b/ch7/ch7-08.md @@ -4,7 +4,7 @@ ```go type error interface { - Error() string + Error() string } ``` @@ -46,17 +46,17 @@ package syscall type Errno uintptr // operating system error code var errors = [...]string{ - 1: "operation not permitted", // EPERM - 2: "no such file or directory", // ENOENT - 3: "no such process", // ESRCH - // ... + 1: "operation not permitted", // EPERM + 2: "no such file or directory", // ENOENT + 3: "no such process", // ESRCH + // ... } func (e Errno) Error() string { - if 0 <= int(e) && int(e) < len(errors) { - return errors[e] - } - return fmt.Sprintf("errno %d", e) + if 0 <= int(e) && int(e) < len(errors) { + return errors[e] + } + return fmt.Sprintf("errno %d", e) } ``` diff --git a/ch7/ch7-09.md b/ch7/ch7-09.md index 939b159..0aa1885 100644 --- a/ch7/ch7-09.md +++ b/ch7/ch7-09.md @@ -18,7 +18,7 @@ pow(x, 3) + pow(y, 3) 下面的五個具體類型表示了具體的表達式類型。Var類型表示對一個變量的引用。（我們很快會知道爲什麽它可以被輸出。）literal類型表示一個浮點型常量。unary和binary類型表示有一到兩個運算對象的運算符表達式，這些操作數可以是任意的Expr類型。call類型表示對一個函數的調用；我們限製它的fn字段隻能是pow，sin或者sqrt。 ```go -// gopl.io/ch7/eval +gopl.io/ch7/eval // A Var identifies a variable, e.g., x. type Var string @@ -27,20 +27,20 @@ type literal float64 // A unary represents a unary operator expression, e.g., -x. type unary struct { - op rune // one of '+', '-' - x Expr + op rune // one of '+', '-' + x Expr } // A binary represents a binary operator expression, e.g., x+y. type binary struct { - op rune // one of '+', '-', '*', '/' - x, y Expr + op rune // one of '+', '-', '*', '/' + x, y Expr } // A call represents a function call expression, e.g., sin(x). type call struct { - fn string // one of "pow", "sin", "sqrt" - args []Expr + fn string // one of "pow", "sin", "sqrt" + args []Expr } ``` @@ -54,8 +54,8 @@ type Env map[Var]float64 ```go type Expr interface { - // Eval returns the value of this Expr in the environment env. - Eval(env Env) float64 + // Eval returns the value of this Expr in the environment env. + Eval(env Env) float64 } ``` @@ -63,11 +63,11 @@ type Expr interface { ```go func (v Var) Eval(env Env) float64 { - return env[v] + return env[v] } func (l literal) Eval(_ Env) float64 { - return float64(l) + return float64(l) } ``` @@ -75,39 +75,39 @@ unary和binary的Eval方法會遞歸的計算它的運算對象，然後將運 ```go func (u unary) Eval(env Env) float64 { - switch u.op { - case '+': - return +u.x.Eval(env) - case '-': - return -u.x.Eval(env) - } - panic(fmt.Sprintf("unsupported unary operator: %q", u.op)) + switch u.op { + case '+': + return +u.x.Eval(env) + case '-': + return -u.x.Eval(env) + } + panic(fmt.Sprintf("unsupported unary operator: %q", u.op)) } func (b binary) Eval(env Env) float64 { - switch b.op { - case '+': - return b.x.Eval(env) + b.y.Eval(env) - case '-': - return b.x.Eval(env) - b.y.Eval(env) - case '*': - return b.x.Eval(env) * b.y.Eval(env) - case '/': - return b.x.Eval(env) / b.y.Eval(env) - } - panic(fmt.Sprintf("unsupported binary operator: %q", b.op)) + switch b.op { + case '+': + return b.x.Eval(env) + b.y.Eval(env) + case '-': + return b.x.Eval(env) - b.y.Eval(env) + case '*': + return b.x.Eval(env) * b.y.Eval(env) + case '/': + return b.x.Eval(env) / b.y.Eval(env) + } + panic(fmt.Sprintf("unsupported binary operator: %q", b.op)) } func (c call) Eval(env Env) float64 { - switch c.fn { - case "pow": - return math.Pow(c.args[0].Eval(env), c.args[1].Eval(env)) - case "sin": - return math.Sin(c.args[0].Eval(env)) - case "sqrt": - return math.Sqrt(c.args[0].Eval(env)) - } - panic(fmt.Sprintf("unsupported function call: %s", c.fn)) + switch c.fn { + case "pow": + return math.Pow(c.args[0].Eval(env), c.args[1].Eval(env)) + case "sin": + return math.Sin(c.args[0].Eval(env)) + case "sqrt": + return math.Sqrt(c.args[0].Eval(env)) + } + panic(fmt.Sprintf("unsupported function call: %s", c.fn)) } ``` @@ -117,37 +117,37 @@ func (c call) Eval(env Env) float64 { ```go func TestEval(t *testing.T) { - tests := []struct { - expr string - env Env - want string - }{ - {"sqrt(A / pi)", Env{"A": 87616, "pi": math.Pi}, "167"}, - {"pow(x, 3) + pow(y, 3)", Env{"x": 12, "y": 1}, "1729"}, - {"pow(x, 3) + pow(y, 3)", Env{"x": 9, "y": 10}, "1729"}, - {"5 / 9 * (F - 32)", Env{"F": -40}, "-40"}, - {"5 / 9 * (F - 32)", Env{"F": 32}, "0"}, - {"5 / 9 * (F - 32)", Env{"F": 212}, "100"}, - } - var prevExpr string - for _, test := range tests { - // Print expr only when it changes. - if test.expr != prevExpr { - fmt.Printf("\n%s\n", test.expr) - prevExpr = test.expr - } - expr, err := Parse(test.expr) - if err != nil { - t.Error(err) // parse error - continue - } - got := fmt.Sprintf("%.6g", expr.Eval(test.env)) - fmt.Printf("\t%v => %s\n", test.env, got) - if got != test.want { - t.Errorf("%s.Eval() in %v = %q, want %q\n", - test.expr, test.env, got, test.want) - } - } + tests := []struct { + expr string + env Env + want string + }{ + {"sqrt(A / pi)", Env{"A": 87616, "pi": math.Pi}, "167"}, + {"pow(x, 3) + pow(y, 3)", Env{"x": 12, "y": 1}, "1729"}, + {"pow(x, 3) + pow(y, 3)", Env{"x": 9, "y": 10}, "1729"}, + {"5 / 9 * (F - 32)", Env{"F": -40}, "-40"}, + {"5 / 9 * (F - 32)", Env{"F": 32}, "0"}, + {"5 / 9 * (F - 32)", Env{"F": 212}, "100"}, + } + var prevExpr string + for _, test := range tests { + // Print expr only when it changes. + if test.expr != prevExpr { + fmt.Printf("\n%s\n", test.expr) + prevExpr = test.expr + } + expr, err := Parse(test.expr) + if err != nil { + t.Error(err) // parse error + continue + } + got := fmt.Sprintf("%.6g", expr.Eval(test.env)) + fmt.Printf("\t%v => %s\n", test.env, got) + if got != test.want { + t.Errorf("%s.Eval() in %v = %q, want %q\n", + test.expr, test.env, got, test.want) + } + } } ``` @@ -181,9 +181,9 @@ pow(x, 3) + pow(y, 3) ```go type Expr interface { - Eval(env Env) float64 - // Check reports errors in this Expr and adds its Vars to the set. - Check(vars map[Var]bool) error + Eval(env Env) float64 + // Check reports errors in this Expr and adds its Vars to the set. + Check(vars map[Var]bool) error } ``` @@ -191,46 +191,46 @@ type Expr interface { ```go func (v Var) Check(vars map[Var]bool) error { - vars[v] = true - return nil + vars[v] = true + return nil } func (literal) Check(vars map[Var]bool) error { - return nil + return nil } func (u unary) Check(vars map[Var]bool) error { - if !strings.ContainsRune("+-", u.op) { - return fmt.Errorf("unexpected unary op %q", u.op) - } - return u.x.Check(vars) + if !strings.ContainsRune("+-", u.op) { + return fmt.Errorf("unexpected unary op %q", u.op) + } + return u.x.Check(vars) } func (b binary) Check(vars map[Var]bool) error { - if !strings.ContainsRune("+-*/", b.op) { - return fmt.Errorf("unexpected binary op %q", b.op) - } - if err := b.x.Check(vars); err != nil { - return err - } - return b.y.Check(vars) + if !strings.ContainsRune("+-*/", b.op) { + return fmt.Errorf("unexpected binary op %q", b.op) + } + if err := b.x.Check(vars); err != nil { + return err + } + return b.y.Check(vars) } func (c call) Check(vars map[Var]bool) error { - arity, ok := numParams[c.fn] - if !ok { - return fmt.Errorf("unknown function %q", c.fn) - } - if len(c.args) != arity { - return fmt.Errorf("call to %s has %d args, want %d", - c.fn, len(c.args), arity) - } - for _, arg := range c.args { - if err := arg.Check(vars); err != nil { - return err - } - } - return nil + arity, ok := numParams[c.fn] + if !ok { + return fmt.Errorf("unknown function %q", c.fn) + } + if len(c.args) != arity { + return fmt.Errorf("call to %s has %d args, want %d", + c.fn, len(c.args), arity) + } + for _, arg := range c.args { + if err := arg.Check(vars); err != nil { + return err + } + } + return nil } var numParams = map[string]int{"pow": 2, "sin": 1, "sqrt": 1} @@ -255,27 +255,27 @@ Check方法的參數是一個Var類型的集合，這個集合聚集從表達式 這個ParseAndCheck函數混合了解析和檢査步驟的過程： ```go -// gopl.io/ch7/surface +gopl.io/ch7/surface import "gopl.io/ch7/eval" func parseAndCheck(s string) (eval.Expr, error) { - if s == "" { - return nil, fmt.Errorf("empty expression") - } - expr, err := eval.Parse(s) - if err != nil { - return nil, err - } - vars := make(map[eval.Var]bool) - if err := expr.Check(vars); err != nil { - return nil, err - } - for v := range vars { - if v != "x" && v != "y" && v != "r" { - return nil, fmt.Errorf("undefined variable: %s", v) - } - } - return expr, nil + if s == "" { + return nil, fmt.Errorf("empty expression") + } + expr, err := eval.Parse(s) + if err != nil { + return nil, err + } + vars := make(map[eval.Var]bool) + if err := expr.Check(vars); err != nil { + return nil, err + } + for v := range vars { + if v != "x" && v != "y" && v != "r" { + return nil, fmt.Errorf("undefined variable: %s", v) + } + } + return expr, nil } ``` @@ -283,17 +283,17 @@ func parseAndCheck(s string) (eval.Expr, error) { ```go func plot(w http.ResponseWriter, r *http.Request) { - r.ParseForm() - expr, err := parseAndCheck(r.Form.Get("expr")) - if err != nil { - http.Error(w, "bad expr: "+err.Error(), http.StatusBadRequest) - return - } - w.Header().Set("Content-Type", "image/svg+xml") - surface(w, func(x, y float64) float64 { - r := math.Hypot(x, y) // distance from (0,0) - return expr.Eval(eval.Env{"x": x, "y": y, "r": r}) - }) + r.ParseForm() + expr, err := parseAndCheck(r.Form.Get("expr")) + if err != nil { + http.Error(w, "bad expr: "+err.Error(), http.StatusBadRequest) + return + } + w.Header().Set("Content-Type", "image/svg+xml") + surface(w, func(x, y float64) float64 { + r := math.Hypot(x, y) // distance from (0,0) + return expr.Eval(eval.Env{"x": x, "y": y, "r": r}) + }) } ``` @@ -301,10 +301,10 @@ func plot(w http.ResponseWriter, r *http.Request) { 這個plot函數解析和檢査在HTTP請求中指定的表達式併且用它來創建一個兩個變量的匿名函數。這個匿名函數和來自原來surface-plotting程序中的固定函數f有相同的籤名，但是它計算一個用戶提供的表達式。環境變量中定義了x，y和半徑r。最後plot調用surface函數，它就是gopl.io/ch3/surface中的主要函數，脩改後它可以接受plot中的函數和輸出io.Writer作爲參數，而不是使用固定的函數f和os.Stdout。圖7.7中顯示了通過程序産生的3個麴面。 -練習7.13：爲Expr增加一個String方法來打印美觀的語法樹。當再一次解析的時候，檢査它的結果是否生成相同的語法樹。 +**練習 7.13：** 爲Expr增加一個String方法來打印美觀的語法樹。當再一次解析的時候，檢査它的結果是否生成相同的語法樹。 -練習7.14：定義一個新的滿足Expr接口的具體類型併且提供一個新的操作例如對它運算單元中的最小值的計算。因爲Parse函數不會創建這個新類型的實例，爲了使用它你可能需要直接構造一個語法樹（或者繼承parser接口）。 +**練習 7.14：** 定義一個新的滿足Expr接口的具體類型併且提供一個新的操作例如對它運算單元中的最小值的計算。因爲Parse函數不會創建這個新類型的實例，爲了使用它你可能需要直接構造一個語法樹（或者繼承parser接口）。 -練習7.15：編寫一個從標準輸入中讀取一個單一表達式的程序，用戶及時地提供對於任意變量的值，然後在結果環境變量中計算表達式的值。優雅的處理所有遇到的錯誤。 +**練習 7.15：** 編寫一個從標準輸入中讀取一個單一表達式的程序，用戶及時地提供對於任意變量的值，然後在結果環境變量中計算表達式的值。優雅的處理所有遇到的錯誤。 -練習7.16：編寫一個基於web的計算器程序。 +**練習 7.16：** 編寫一個基於web的計算器程序。 diff --git a/ch7/ch7-10.md b/ch7/ch7-10.md index 1b9ff22..1a11578 100644 --- a/ch7/ch7-10.md +++ b/ch7/ch7-10.md @@ -1,16 +1,20 @@ ## 7.10. 類型斷言 + 類型斷言是一個使用在接口值上的操作。語法上它看起來像x.(T)被稱爲斷言類型，這里x表示一個接口的類型和T表示一個類型。一個類型斷言檢査它操作對象的動態類型是否和斷言的類型匹配。 這里有兩種可能。第一種，如果斷言的類型T是一個具體類型，然後類型斷言檢査x的動態類型是否和T相同。如果這個檢査成功了，類型斷言的結果是x的動態值，當然它的類型是T。換句話説，具體類型的類型斷言從它的操作對象中獲得具體的值。如果檢査失敗，接下來這個操作會拋出panic。例如： + ```go var w io.Writer w = os.Stdout f := w.(*os.File) // success: f == os.Stdout c := w.(*bytes.Buffer) // panic: interface holds *os.File, not *bytes.Buffer ``` + 第二種，如果相反斷言的類型T是一個接口類型，然後類型斷言檢査是否x的動態類型滿足T。如果這個檢査成功了，動態值沒有獲取到；這個結果仍然是一個有相同類型和值部分的接口值，但是結果有類型T。換句話説，對一個接口類型的類型斷言改變了類型的表述方式，改變了可以獲取的方法集合（通常更大），但是它保護了接口值內部的動態類型和值的部分。 在下面的第一個類型斷言後，w和rw都持有os.Stdout因此它們每個有一個動態類型*os.File，但是變量w是一個io.Writer類型隻對外公開出文件的Write方法，然而rw變量也隻公開它的Read方法。 + ```go var w io.Writer w = os.Stdout @@ -18,28 +22,36 @@ rw := w.(io.ReadWriter) // success: *os.File has both Read and Write w = new(ByteCounter) rw = w.(io.ReadWriter) // panic: *ByteCounter has no Read method ``` + 如果斷言操作的對象是一個nil接口值，那麽不論被斷言的類型是什麽這個類型斷言都會失敗。我們幾乎不需要對一個更少限製性的接口類型（更少的方法集合）做斷言，因爲它表現的就像賦值操作一樣，除了對於nil接口值的情況。 + ```go w = rw // io.ReadWriter is assignable to io.Writer w = rw.(io.Writer) // fails only if rw == nil ``` + 經常地我們對一個接口值的動態類型是不確定的，併且我們更願意去檢驗它是否是一些特定的類型。如果類型斷言出現在一個預期有兩個結果的賦值操作中，例如如下的定義，這個操作不會在失敗的時候發生panic但是代替地返迴一個額外的第二個結果，這個結果是一個標識成功的布爾值： + ```go var w io.Writer = os.Stdout f, ok := w.(*os.File) // success: ok, f == os.Stdout b, ok := w.(*bytes.Buffer) // failure: !ok, b == nil ``` + 第二個結果常規地賦值給一個命名爲ok的變量。如果這個操作失敗了，那麽ok就是false值，第一個結果等於被斷言類型的零值，在這個例子中就是一個nil的*bytes.Buffer類型。 這個ok結果經常立卽用於決定程序下面做什麽。if語句的擴展格式讓這個變的很簡潔： + ```go if f, ok := w.(*os.File); ok { - // ...use f... + // ...use f... } ``` + 當類型斷言的操作對象是一個變量，你有時會看見原來的變量名重用而不是聲明一個新的本地變量，這個重用的變量會覆蓋原來的值，如下面這樣： + ```go if w, ok := w.(*os.File); ok { - // ...use w... + // ...use w... } ```