Effective Go(有效的 GO)[3]

方法

指针与值

type ByteSlice []byte

func (slice ByteSlice) Append(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
}

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...))
}