Effective Go(实效 GO 编程)

引言

示例

格式化

type T struct {
    name string // name of the object
    value int // its value
}

type T struct {
    name    string // name of the object
    value   int    // its value
}

x<<8 + y<<16

注释

名称

包名称

import "bytes"

导入者的命名

Getter

owner := obj.Owner()
if owner != user {
    obj.SetOwner(user)
}

接口名称

MixedCaps

分号

break continue fallthrough return ++ -- ) }

go func() { for { dst <- <-src } }()

if i < f() {
    g()
}

if i < f()  // wrong!
{           // wrong!
    g()
}

控制结构

if

if x > 0 {
    return y
}

if err := file.Chmod(0664); err != nil {
    log.Print(err)
    return err
}

f, err := os.Open(name)
if err != nil {
    return err
}
codeUsing(f)

f, err := os.Open(name)
if err != nil {
    return err
}
d, err := f.Stat()
if err != nil {
    f.Close()
    return err
}
codeUsing(f, d)

重新声明和重新赋值

f, err := os.Open(name)

d, err := f.Stat()

• 该声明与现有的 v 声明在同一作用域内（如果 v 已在外部作用域中声明，则该声明会创建一个新变量），

• 初始化中的对应值可以赋值给 v，并且

• 该声明创建了至少一个其他变量。

for

// 类似于 C 的 for
for init; condition; post { }

// 类似于 C 的 while
for condition { }

// 类似于 C 的 for(;;)
for { }

sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

for key, value := range oldMap {
    newMap[key] = value
}

for key := range m {
    if key.expired() {
        delete(m, key)
    }
}

sum := 0
for _, value := range array {
    sum += value
}

for pos, char := range "日本\\x80語" { // \\x80 是非法的 UTF-8 编码
    fmt.Printf("character %#U starts at byte position %d\\n", char, pos)
}

character U+65E5 '日' starts at byte position 0
character U+672C '本' starts at byte position 3
character U+FFFD '�' starts at byte position 6
character U+8A9E '語' starts at byte position 7

// 反转数组
for i, j := 0, len(a)-1; i < j; i, j = i+1, j-1 {
    a[i], a[j] = a[j], a[i]
}

switch

func unhex(c byte) byte {
    switch {
    case '0' <= c && c <= '9':
        return c - '0'
    case 'a' <= c && c <= 'f':
        return c - 'a' + 10
    case 'A' <= c && c <= 'F':
        return c - 'A' + 10
    }
    return 0
}

func shouldEscape(c byte) bool {
    switch c {
    case ' ', '?', '&', '=', '#', '+', '%':
        return true
    }
    return false
}

Loop:
    for n := 0; n < len(src); n += size {
        switch {
        case src[n] < sizeOne:
            if validateOnly {
                break
            }
            size = 1
            update(src[n])

        case src[n] < sizeTwo:
            if n+1 >= len(src) {
                err = errShortInput
                break Loop
            }
            if validateOnly {
                break
            }
            size = 2
            update(src[n] + src[n+1]<<shift)
        }
    }

// Compare 返回两个字节切片的比较结果，
// 按字典序比较。
// 如果 a == b，结果为 0；如果 a < b，结果为 -1；如果 a > b，结果为 +1
func Compare(a, b []byte) int {
    for i := 0; i < len(a) && i < len(b); i++ {
        switch {
        case a[i] > b[i]:
            return 1
        case a[i] < b[i]:
            return -1
        }
    }
    switch {
    case len(a) > len(b):
        return 1
    case len(a) < len(b):
        return -1
    }
    return 0
}

类型开关

var t interface{}
t = functionOfSomeType()
switch t := t.(type) {
default:
    fmt.Printf("unexpected type %T\\n", t)     // %T 打印 t 的类型
case bool:
    fmt.Printf("boolean %t\\n", t)             // t 的类型是 bool
case int:
    fmt.Printf("integer %d\\n", t)             // t 的类型是 int
case *bool:
    fmt.Printf("pointer to boolean %t\\n", *t) // t 的类型是 *bool
case *int:
    fmt.Printf("pointer to integer %d\\n", *t) // t 的类型是 *int
}

函数

多个返回值

func (file *File) Write(b []byte) (n int, err error)

func nextInt(b []byte, i int) (int, int) {
    for ; i < len(b) && !isDigit(b[i]); i++ {
    }
    x := 0
    for ; i < len(b) && isDigit(b[i]); i++ {
        x = x*10 + int(b[i]) - '0'
    }
    return x, i
}

for i := 0; i < len(b); {
        x, i = nextInt(b, i)
        fmt.Println(x)
    }

命名结果参数

func nextInt(b []byte, pos int) (value, nextPos int) {

func ReadFull(r Reader, buf []byte) (n int, err error) {
    for len(buf) > 0 && err == nil {
        var nr int
        nr, err = r.Read(buf)
        n += nr
        buf = buf[nr:]
    }
    return
}

defer

// Contents 返回文件的内容作为字符串。
func Contents(filename string) (string, error) {
    f, err := os.Open(filename)
    if err != nil {
        return "", err
    }
    defer f.Close()  // f.Close 会在我们完成时运行。

    var result []byte
    buf := make([]byte, 100)
    for {
        n, err := f.Read(buf[0:])
        result = append(result, buf[0:n]...) // append 在后面讨论。
        if err != nil {
            if err == io.EOF {
                break
            }
            return "", err  // 如果我们在这里返回，f 将被关闭。
        }
    }
    return string(result), nil // 如果我们在这里返回，f 将被关闭。
}

for i := 0; i < 5; i++ {
    defer fmt.Printf("%d ", i)
}

func trace(s string)   { fmt.Println("entering:", s) }
func untrace(s string) { fmt.Println("leaving:", s) }

// 这样使用它们：
func a() {
    trace("a")
    defer untrace("a")
    // 做一些事情....
}

func trace(s string) string {
    fmt.Println("entering:", s)
    return s
}

func un(s string) {
    fmt.Println("leaving:", s)
}

func a() {
    defer un(trace("a"))
    fmt.Println("in a")
}

func b() {
    defer un(trace("b"))
    fmt.Println("in b")
    a()
}

func main() {
    b()
}

entering: b
in b
entering: a
in a
leaving: a
leaving: b

数据

使用 new 进行分配

type SyncedBuffer struct {
    lock    sync.Mutex
    buffer  bytes.Buffer
}

p := new(SyncedBuffer)  // 类型 *SyncedBuffer
var v SyncedBuffer      // 类型 SyncedBuffer

构造函数和复合字面量

func NewFile(fd int, name string) *File {
    if fd < 0 {
        return nil
    }
    f := new(File)
    f.fd = fd
    f.name = name
    f.dirinfo = nil
    f.nepipe = 0
    return f
}

func NewFile(fd int, name string) *File {
    if fd < 0 {
        return nil
    }
    f := File{fd, name, nil, 0}
    return &f
}

return &File{fd, name, nil, 0}

return &File{fd: fd, name: name}

a := [...]string   {Enone: "no error", Eio: "Eio", Einval: "invalid argument"}
s := []string      {Enone: "no error", Eio: "Eio", Einval: "invalid argument"}
m := map[int]string{Enone: "no error", Eio: "Eio", Einval: "invalid argument"}

使用 make 进行分配

make([]int, 10, 100)

var p *[]int = new([]int)       // 分配切片结构；*p == nil；很少有用
var v  []int = make([]int, 100) // 切片 v 现在指向一个新数组，包含 100 个整数

// 不必要的复杂：
var p *[]int = new([]int)
*p = make([]int, 100, 100)

// 习惯用法：
v := make([]int, 100)

数组

• 数组是值。将一个数组赋值给另一个数组会复制所有元素。

• 特别是，如果将数组传递给函数，它将接收一个 副本，而不是指向它的指针。

• 数组的大小是其类型的一部分。类型 [10]int 和 [20]int 是不同的。

func Sum(a *[3]float64) (sum float64) {
    for _, v := range *a {
        sum += v
    }
    return
}

array := [...]float64{7.0, 8.5, 9.1}
x := Sum(&array)  // 注意显式的取地址操作符

切片

func (f *File) Read(buf []byte) (n int, err error)

n, err := f.Read(buf[0:32])

var n int
var err error
for i := 0; i < 32; i++ {
    nbytes, e := f.Read(buf[i:i+1])  // 读取一个字节。
    n += nbytes
    if nbytes == 0 || e != nil {
        err = e
        break
    }
}

func Append(slice, data []byte) []byte {
    l := len(slice)
    if l + len(data) > cap(slice) {  // 重新分配
        // 分配所需的两倍，以便将来增长。
        newSlice := make([]byte, (l+len(data))*2)
        // copy 函数是预定义的，适用于任何切片类型。
        copy(newSlice, slice)
        slice = newSlice
    }
    slice = slice[0:l+len(data)]
    copy(slice[l:], data)
    return slice
}

二维切片

type Transform [3][3]float64  // 3x3 数组，实际上是数组的数组。
type LinesOfText [][]byte     // 字节切片的切片。

text := LinesOfText{
    []byte("Now is the time"),
    []byte("for all good gophers"),
    []byte("to bring some fun to the party."),
}

// 分配顶层切片。
picture := make([][]uint8, YSize) // 每个 y 单元一行。
// 循环分配每一行的切片。
for i := range picture {
    picture[i] = make([]uint8, XSize)
}

// 分配顶层切片，与之前相同。
picture := make([][]uint8, YSize) // 每个 y 单元一行。
// 分配一个大型切片以容纳所有像素。
pixels := make([]uint8, XSize*YSize) // 类型为 []uint8，尽管 picture 是 [][]uint8。
// 循环切片每一行，切片每一行从剩余的像素切片的前面切出。
for i := range picture {
    picture[i], pixels = pixels[:XSize], pixels[XSize:]
}

映射

var timeZone = map[string]int{
    "UTC":  0*60*60,
    "EST": -5*60*60,
    "CST": -6*60*60,
    "MST": -7*60*60,
    "PST": -8*60*60,
}

offset := timeZone["EST"]

attended := map[string]bool{
    "Ann": true,
    "Joe": true,
    ...
}

if attended[person] { // 如果 person 不在映射中，将为 false
    fmt.Println(person, "was at the meeting")
}

var seconds int
var ok bool
seconds, ok = timeZone[tz]

func offset(tz string) int {
    if seconds, ok := timeZone[tz]; ok {
        return seconds
    }
    log.Println("unknown time zone:", tz)
    return 0
}

_, present := timeZone[tz]

delete(timeZone, "PDT")  // Now on Standard Time

打印

fmt.Printf("Hello %d\\n", 23)
fmt.Fprint(os.Stdout, "Hello ", 23, "\\n")
fmt.Println("Hello", 23)
fmt.Println(fmt.Sprint("Hello ", 23))

var x uint64 = 1<<64 - 1
fmt.Printf("%d %x; %d %x\\n", x, x, int64(x), int64(x))

18446744073709551615 ffffffffffffffff; -1 -1

fmt.Printf("%v\\n", timeZone)  // 或者直接使用 fmt.Println(timeZone)

map[CST:-21600 EST:-18000 MST:-25200 PST:-28800 UTC:0]

type T struct {
    a int
    b float64
    c string
}
t := &T{ 7, -2.35, "abc\\tdef" }
fmt.Printf("%v\\n", t)
fmt.Printf("%+v\\n", t)
fmt.Printf("%#v\\n", t)
fmt.Printf("%#v\\n", timeZone)

&{7 -2.35 abc   def}
&{a:7 b:-2.35 c:abc     def}
&main.T{a:7, b:-2.35, c:"abc\\tdef"}
map[string]int{"CST":-21600, "EST":-18000, "MST":-25200, "PST":-28800, "UTC":0}

fmt.Printf("%T\\n", timeZone)

map[string]int

func (t *T) String() string {
    return fmt.Sprintf("%d/%g/%q", t.a, t.b, t.c)
}
fmt.Printf("%v\\n", t)

7/-2.35/"abc\\tdef"

type MyString string

func (m MyString) String() string {
    return fmt.Sprintf("MyString=%s", m) // 错误：将无限递归。
}

type MyString string
func (m MyString) String() string {
    return fmt.Sprintf("MyString=%s", string(m)) // 正确：注意转换。
}

func Printf(format string, v ...interface{}) (n int, err error) {

// Println 以 fmt.Println 的方式打印到标准日志。
func Println(v ...interface{}) {
    std.Output(2, fmt.Sprintln(v...))  // Output 接受参数 (int, string)
}

func Min(a ...int) int {
    min := int(^uint(0) >> 1)  // 最大的 int
    for _, i := range a {
        if i < min {
            min = i
        }
    }
    return min
}

附加

func append(slice []T, elements ...T) []T

x := []int{1,2,3}
x = append(x, 4, 5, 6)
fmt.Println(x)

x := []int{1,2,3}
y := []int{4,5,6}
x = append(x, y...)
fmt.Println(x)

初始化

常量

type ByteSize float64

const (
    _           = iota // 忽略第一个值，通过分配给空白标识符
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
    TB
    PB
    EB
    ZB
    YB
)

func (b ByteSize) String() string {
    switch {
    case b >= YB:
        return fmt.Sprintf("%.2fYB", b/YB)
    case b >= ZB:
        return fmt.Sprintf("%.2fZB", b/ZB)
    case b >= EB:
        return fmt.Sprintf("%.2fEB", b/EB)
    case b >= PB:
        return fmt.Sprintf("%.2fPB", b/PB)
    case b >= TB:
        return fmt.Sprintf("%.2fTB", b/TB)
    case b >= GB:
        return fmt.Sprintf("%.2fGB", b/GB)
    case b >= MB:
        return fmt.Sprintf("%.2fMB", b/MB)
    case b >= KB:
        return fmt.Sprintf("%.2fKB", b/KB)
    }
    return fmt.Sprintf("%.2fB", b)
}

变量

var (
    home   = os.Getenv("HOME")
    user   = os.Getenv("USER")
    gopath = os.Getenv("GOPATH")
)

init 函数

func init() {
    if user == "" {
        log.Fatal("$USER not set")
    }
    if home == "" {
        home = "/home/" + user
    }
    if gopath == "" {
        gopath = home + "/go"
    }
    // gopath 可能会被命令行中的 --gopath 标志覆盖。
    flag.StringVar(&gopath, "gopath", gopath, "override default GOPATH")
}

方法

指针与值

type ByteSlice []byte

func (slice ByteSlice) Append(data []byte) []byte {
    // 函数体与上面定义的 Append 函数完全相同。
}

func (p *ByteSlice) Append(data []byte) {
    slice := *p
    // 函数体与上面相同，无需返回。
    *p = slice
}

func (p *ByteSlice) Write(data []byte) (n int, err error) {
    slice := *p
    // 同样的函数体。
    *p = slice
    return len(data), nil
}

var b ByteSlice
fmt.Fprintf(&b, "This hour has %d days\\n", 7)

接口与其他类型

接口

type Sequence []int

// sort.Interface 所需的方法。
func (s Sequence) Len() int {
    return len(s)
}
func (s Sequence) Less(i, j int) bool {
    return s[i] < s[j]
}
func (s Sequence) Swap(i, j int) {
    s[i], s[j] = s[j], s[i]
}

// Copy 返回 Sequence 的副本。
func (s Sequence) Copy() Sequence {
    copy := make(Sequence, 0, len(s))
    return append(copy, s...)
}

// 打印的方法 - 在打印之前对元素进行排序。
func (s Sequence) String() string {
    s = s.Copy() // 复制；不要覆盖参数。
    sort.Sort(s)
    str := "["
    for i, elem := range s { // 循环是 O(N²)；在下一个例子中会修复。
        if i > 0 {
            str += " "
        }
        str += fmt.Sprint(elem)
    }
    return str + "]"
}

转换

func (s Sequence) String() string {
    s = s.Copy()
    sort.Sort(s)
    return fmt.Sprint([]int(s))
}

type Sequence []int

// 打印的方法 - 在打印之前对元素进行排序。
func (s Sequence) String() string {
    s = s.Copy()
    sort.IntSlice(s).Sort()
    return fmt.Sprint([]int(s))
}

接口转换与类型断言

type Stringer interface {
    String() string
}

var value interface{} // 由调用者提供的值。
switch str := value.(type) {
case string:
    return str
case Stringer:
    return str.String()
}

value.(typeName)

str := value.(string)

str, ok := value.(string)
if ok {
    fmt.Printf("string value is: %q\\n", str)
} else {
    fmt.Printf("value is not a string\\n")
}

if str, ok := value.(string); ok {
    return str
} else if str, ok := value.(Stringer); ok {
    return str.String()
}

泛化

type Block interface {
    BlockSize() int
    Encrypt(dst, src []byte)
    Decrypt(dst, src []byte)
}

type Stream interface {
    XORKeyStream(dst, src []byte)
}

// NewCTR 返回一个使用给定 Block 进行加密/解密的 Stream，
// 以计数器模式工作。iv 的长度必须与 Block 的块大小相同。
func NewCTR(block Block, iv []byte) Stream

接口和方法

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

// 简单计数服务器。
type Counter struct {
    n int
}

func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    ctr.n++
    fmt.Fprintf(w, "counter = %d\\n", ctr.n)
}

import "net/http"
...
ctr := new(Counter)
http.Handle("/counter", ctr)

// 更简单的计数服务器。
type Counter int

func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    *ctr++
    fmt.Fprintf(w, "counter = %d\\n", *ctr)
}

// 每次访问时发送通知的通道。
// （可能希望通道是缓冲的。）
type Chan chan *http.Request

func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    ch <- req
    fmt.Fprint(w, "notification sent")
}

func ArgServer() {
    fmt.Println(os.Args)
}

// HandlerFunc 类型是一个适配器，允许使用
// 普通函数作为 HTTP 处理程序。如果 f 是一个具有适当签名的函数，
// HandlerFunc(f) 是一个 Handler 对象，它调用 f。
type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP 调用 f(w, req)。
func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
    f(w, req)
}

// 参数服务器。
func ArgServer(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintln(w, os.Args)
}

http.Handle("/args", http.HandlerFunc(ArgServer))

空白标识符

在多重赋值中的空白标识符

if _, err := os.Stat(path); os.IsNotExist(err) {
    fmt.Printf("%s does not exist\\n", path)
}

// 糟糕！如果路径不存在，这段代码将崩溃。
fi, _ := os.Stat(path)
if fi.IsDir() {
    fmt.Printf("%s is a directory\\n", path)
}

未使用的导入和变量

package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

func main() {
    fd, err := os.Open("test.go")
    if err != nil {
        log.Fatal(err)
    }
    // TODO: use fd.
}

package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

var _ = fmt.Printf // 用于调试；完成后删除。
var _ io.Reader    // 用于调试；完成后删除。

func main() {
    fd, err := os.Open("test.go")
    if err != nil {
        log.Fatal(err)
    }
    // TODO: use fd.
    _ = fd
}

仅为副作用导入

import _ "net/http/pprof"

接口检查

m, ok := val.(json.Marshaler)

if _, ok := val.(json.Marshaler); ok {
    fmt.Printf("value %v of type %T implements json.Marshaler\\n", val, val)
}

var _ json.Marshaler = (*RawMessage)(nil)

嵌入

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

// ReadWriter 是结合 Reader 和 Writer 接口的接口。
type ReadWriter interface {
    Reader
    Writer
}

// ReadWriter 存储对 Reader 和 Writer 的指针。
// 它实现了 io.ReadWriter。
type ReadWriter struct {
    *Reader  // *bufio.Reader
    *Writer  // *bufio.Writer
}

type ReadWriter struct {
    reader *Reader
    writer *Writer
}

func (rw *ReadWriter) Read(p []byte) (n int, err error) {
    return rw.reader.Read(p)
}

type Job struct {
    Command string
    *log.Logger
}

job.Println("starting now...")

func NewJob(command string, logger *log.Logger) *Job {
    return &Job{command, logger}
}

job := &Job{command, log.New(os.Stderr, "Job: ", log.Ldate)}

func (job *Job) Printf(format string, args ...interface{}) {
    job.Logger.Printf("%q: %s", job.Command, fmt.Sprintf(format, args...))
}

并发

通过通信共享

不要通过共享内存进行通信；相反，通过通信共享内存。

Goroutines

go list.Sort()  // 并发运行 list.Sort；不等待它完成。

func Announce(message string, delay time.Duration) {
    go func() {
        time.Sleep(delay)
        fmt.Println(message)
    }()  // 注意括号 - 必须调用该函数。
}

通道

ci := make(chan int)            // 无缓冲的整数通道
cj := make(chan int, 0)         // 无缓冲的整数通道
cs := make(chan *os.File, 100)  // 有缓冲的文件指针通道

c := make(chan int)  // 分配一个通道。
// 在 goroutine 中启动排序；完成后在通道上发送信号。
go func() {
    list.Sort()
    c <- 1  // 发送信号；值无关紧要。
}()
doSomethingForAWhile()
<-c   // 等待排序完成；丢弃发送的值。

var sem = make(chan int, MaxOutstanding)

func handle(r *Request) {
    sem <- 1    // 等待活动队列排空。
    process(r)  // 可能需要很长时间。
    <-sem       // 完成；允许下一个请求运行。
}

func Serve(queue chan *Request) {
    for {
        req := <-queue
        go handle(req)  // 不等待 handle 完成。
    }
}

func Serve(queue chan *Request) {
    for req := range queue {
        sem <- 1
        go func() {
            process(req)
            <-sem
        }()
    }
}

func handle(queue chan *Request) {
    for r := range queue {
        process(r)
    }
}

func Serve(clientRequests chan *Request, quit chan bool) {
    // 启动处理程序
    for i := 0; i < MaxOutstanding; i++ {
        go handle(clientRequests)
    }
    <-quit  // 等待退出信号。
}

通道的通道

type Request struct {
    args        []int
    f           func([]int) int
    resultChan  chan int
}

func sum(a []int) (s int) {
    for _, v := range a {
        s += v
    }
    return
}

request := &Request{[]int{3, 4, 5}, sum, make(chan int)}
// 发送请求
clientRequests <- request
// 等待响应。
fmt.Printf("answer: %d\\n", <-request.resultChan)

func handle(queue chan *Request) {
    for req := range queue {
        req.resultChan <- req.f(req.args)
    }
}

并行化

type Vector []float64

// 对 v[i], v[i+1] ... 直到 v[n-1] 应用操作。
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
    for ; i < n; i++ {
        v[i] += u.Op(v[i])
    }
    c <- 1    // 信号表示这一部分完成
}

const numCPU = 4 // CPU 核心数量

func (v Vector) DoAll(u Vector) {
    c := make(chan int, numCPU)  // 缓冲是可选的，但合理。
    for i := 0; i < numCPU; i++ {
        go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
    }
    // 清空通道。
    for i := 0; i < numCPU; i++ {
        <-c    // 等待一个任务完成
    }
    // 完成所有操作。
}

var numCPU = runtime.NumCPU()

var numCPU = runtime.GOMAXPROCS(0)

漏水的缓冲区

var freeList = make(chan *Buffer, 100)
var serverChan = make(chan *Buffer)

func client() {
    for {
        var b *Buffer
        // 如果可用，则获取一个缓冲区；如果没有，则分配一个新的。
        select {
        case b = <-freeList:
            // 获取一个；无需其他操作。
        default:
            // 没有空闲的，因此分配一个新的。
            b = new(Buffer)
        }
        load(b)              // 从网络读取下一条消息。
        serverChan <- b      // 发送到服务器。
    }
}

func server() {
    for {
        b := <-serverChan    // 等待工作。
        process(b)
        // 如果有空间，则重用缓冲区。
        select {
        case freeList <- b:
            // 缓冲区在空闲列表中；无需其他操作。
        default:
            // 空闲列表已满，继续进行。
        }
    }
}

错误处理

type error interface {
    Error() string
}

// PathError 记录了导致错误的操作和文件路径。
type PathError struct {
    Op   string // "open", "unlink" 等
    Path string // 相关文件
    Err  error  // 系统调用返回的错误
}

func (e *PathError) Error() string {
    return e.Op + " " + e.Path + ": " + e.Err.Error()
}

open /etc/passwx: no such file or directory

for try := 0; try < 2; try++ {
    file, err = os.Create(filename)
    if err == nil {
        return
    }
    if e, ok := err.(*os.PathError); ok && e.Err == syscall.ENOSPC {
        deleteTempFiles()  // 回收一些空间。
        continue
    }
    return
}

恐慌处理

// 使用牛顿法实现立方根的简单示例。
func CubeRoot(x float64) float64 {
    z := x / 3  // 任意初始值
    for i := 0; i < 1e6; i++ {
        prevz := z
        z -= (z*z*z - x) / (3*z*z)
        if veryClose(z, prevz) {
            return z
        }
    }
    // 百万次迭代未收敛；出现问题。
    panic(fmt.Sprintf("CubeRoot(%g) did not converge", x))
}

var user = os.Getenv("USER")

func init() {
    if user == "" {
        panic("no value for $USER")
    }
}

恢复处理

func server(workChan <-chan *Work) {
    for work := range workChan {
        go safelyDo(work)
    }
}

func safelyDo(work *Work) {
    defer func() {
        if err := recover(); err != nil {
            log.Println("work failed:", err)
        }
    }()
    do(work)
}

// Error 是解析错误的类型；它满足 error 接口。
type Error string
func (e Error) Error() string {
    return string(e)
}

// error 是 *Regexp 的一个方法，通过
// 使用 panic 处理解析错误。
func (regexp *Regexp) error(err string) {
    panic(Error(err))
}

// Compile 返回正则表达式的解析表示。
func Compile(str string) (regexp *Regexp, err error) {
    regexp = new(Regexp)
    // doParse 如果有解析错误将会 panic。
    defer func() {
        if e := recover(); e != nil {
            regexp = nil    // 清除返回值。
            err = e.(Error) // 如果不是解析错误将重新 panic。
        }
    }()
    return regexp.doParse(str), nil
}

if pos == 0 {
    re.error("'*' illegal at start of expression")
}

一个 Web 服务器

package main

import (
    "flag"
    "html/template"
    "log"
    "net/http"
)

var addr = flag.String("addr", ":1718", "http service address") // Q=17, R=18

var templ = template.Must(template.New("qr").Parse(templateStr))

func main() {
    flag.Parse()
    http.Handle("/", http.HandlerFunc(QR))
    err := http.ListenAndServe(*addr, nil)
    if err != nil {
        log.Fatal("ListenAndServe:", err)
    }
}

func QR(w http.ResponseWriter, req *http.Request) {
    templ.Execute(w, req.FormValue("s"))
}

const templateStr = `
<html>
<head>
<title>QR Link Generator</title>
</head>
<body>
{{if .}}
<img src="<http://chart.apis.google.com/chart?chs=300x300&cht=qr&choe=UTF-8&chl={{.}>}" />
<br>
{{.}}
<br>
<br>
{{end}}
<form action="/" name=f method="GET">
    <input maxLength=1024 size=70 name=s value="" title="Text to QR Encode">
    <input type=submit value="Show QR" name=qr>
</form>
</body>
</html>
`