effect go

技术文章/golang

golang语法详解

golang中的继承并非面向对象意义上的继承，只是一种匿名变量

golang中如何保证类型TA实现了接口IA

var _ IA = &TA{}

使用go vet检查代码，发现隐蔽错误

    log.Errorf("ping mysql faield: source[%s], err[%d]", source, err)

string和[]byte相互转换的成本

从概念上讲，一个[]byte(s)转换是分配了一个新的字节数组用于保存字符串数据的拷贝，然后引用这个底层的字节数组。编译器的优化可以避免在一些场景下分配和复制字符串数据，但总的来说需要确保在变量b被修改的情况下，原始的s字符串也不会改变。将一个字节slice转到字符串的string(b)操作则是构造一个字符串拷贝，以确保s2字符串是只读的。

为了避免转换中不必要的内存分配，bytes包和strings同时提供了许多实用函数。

nil值的slice

一个nil值的slice的行为和其它任意0长度的slice一样；例如reverse(nil)也是安全的。

结构体匿名成员

任何命名的类型都可以作为结构体的匿名成员

go的函数值是一个闭包

函数值不仅仅是一串代码，还记录了状态

我们经常选择一个方法，并且在同一个表达式里执行，比如常见的p.Distance()形式，实际上将其分成两步来执行也是可能的。p.Distance叫作“选择器”，选择器会返回一个方法"值"->一个将方法(Point.Distance)绑定到特定接收器变量的函数。这个函数可以不通过指定其接收器即可被调用；即调用时不需要指定接收器，只要传入函数的参数即可：

p := Point{1, 2}
q := Point{4, 6}
distanceFromP := p.Distance        // method value
fmt.Println(distanceFromP(q))      // "5"
var origin Point                   // {0, 0}
fmt.Println(distanceFromP(origin)) // "2.23606797749979", sqrt(5)
scaleP := p.ScaleBy // method value
scaleP(2)           // p becomes (2, 4)
scaleP(3)           //      then (6, 12)
scaleP(10)          //      then (60, 120)

golang中的坑

往接口赋值指针

一个包含nil指针的接口不是nil接口

func NilFile() *os.File {
        return nil
}
func test1() {
        var r io.Reader
        r = NilFile()
        if r == nil {
                fmt.Printf("r is nil\n")
        } else {
                fmt.Printf("r is not nil\n")
        }
}

接口值是否可比较

interface{}与其他类型如int型的比较

func test4() {
    v.Get("c5") == int64(i+1)
}

defer

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

select

func test3() {
        c := make(chan struct{})
        select {
        case <-c:
        default:
        }
        fmt.Printf("test done\n")
}

不定参数

func printf(format string, args ...interface{}) {
    fmt.Printf(format, args)
}

词法作用域的陷阱

函数值中记录的是循环变量的内存地址，而不是循环变量某一时刻的值

package main
import "fmt"
func test1() {
        for _, s := range []string{"hello", "world", "test"} {
                defer func() {
                        fmt.Printf("%s\n", s)
                }()
        }
}
func test2() {
        for _, s := range []string{"hello", "world", "test"} {
                defer fmt.Printf("%s\n", s)
        }
}
func test() {
        test1()
        test2()
}

func Test1(t *testing.T) {
        var ints = []int{0, 1, 2, 3}
        var wg sync.WaitGroup
        for _, i := range ints {
                wg.Add(1)
                go func(p *int) {
                        defer wg.Done()
                        fmt.Println(*p)
                }(&i)
        }
        wg.Wait()
}