Go Introduction

语言特性

keywords: break      default       func     interface   select
          case       defer         go       map         struct
          chan       else          goto     package     switch
          const      fallthrough   if       range       type
          continue   for           import   return      var
constant: true false iota nil
type:     int int8-64 uint8-64 float32-64 complex64-128
          bool byte rune uintptr string error
function: make len cap new append copy close delete complex real imag
          panic recover

数据类型

• 基本类型
  

  变量声明时变量名在类型名之前，支持多变量定义及赋值，多变量赋值的要点是先计算后赋值。简短声明需要注意作用域问题，在内嵌块中用简短声明同名变量时会产生新的变量，这种特性有可能产生很难调试的问题。

  整数类型int的长度由CPU而定，另一个和机器相关的类型是uintptr。字符类型rune等价于uint32，同样byte也是int8的等价类型。

  Go语言不支持隐式类型转换，即便是整型向布尔转换也不行。对于无类型常量，编译器提供至少32字节的运算精度，这个精度大于Go语言中整型量。将无类型常量复制给变量时，可能会发生隐式转换，因为无类型常量也可以认为有一个最佳匹配类型。

  字符串被设计为不可变对象，也就是不能修改字符，字符串末尾没有空字符。字符串支持切片操作。用``定义的字符串不对转义字符转义，支持跨行，这种形式称作原生字符串。要修改字符串可以转换为[]rune或[]byte数组再修改，转换会复制内存。遍历字符串用range完成，要按字节遍历可以直接用下标访问。用len()对字符串计算长度得到的是字符串的字节数。

  数组被设计为数值类型，赋值和参数传递会复制整个数组。指针数组[n]*T和数组指针*[n]T表达上看星号位置。因为数组是值传递，所以实际上很少会用到，大多情况都使用切片。

  指针不支持算术运算，但支持解引用和成员操作符，成员操作符统一用点操作，箭头不再具有取成员的功能。比较特别的是返回局部变量的指针是安全的，这种情况编译器会做逃逸分析并视情况选择是否在堆上分配。

  函数new()用于创建对象，并返回一个指针。由于返回自动变量的指针是安全的，所以new()本身可有可无，好处是可以让代码更简洁一点。

  关键字type用于定义新类型，和C语言的typedef相似。但是需要强调即便是用同一个类型衍生的两个类型，也表示不同的类型，因此相互之间不能直接比较和运算。

• 复合类型
  

  切片类型和数组在形式上的区别是切片没有指定长度，并且切片不能像数组一样直接进行比较。对数组执行切片操作，就能得到一个切片类型，为了节省内存，切片之后并不会复制内存。

  struct slice
  {
          byte*    array;      // actual data
          uintgo   len;        // number of elements
          uintgo   cap;        // allocated number of elements
  };
  array := [...]int{0, 1, 2, 3, 4, 5, 6}
  slice := array[1:4:5]                    // [beg:end:cap]
  

  append(s, x…)

  用于向slice尾部添加数据，超出cap就会重新分配并复制。

  copy(dst, src)

  复制以长度小的为准，复制本身不会分配内存

  对切片是否为空的测试应利用长度来判断，而不是直接和nil比较。因为存在长度为0但是本身却不为nil的情况。

  映射是基于哈希表的引用类型，支持index、delete操作。索引取回的是复制品，对成员修改并不会作用到映射中的数据，只能是用一个新的值去替换。迭代时可以删除，但是不要新增。

过程控制

• 表达式
  

  Go语言在运算符优先级上也做了较大简化，如下所示，一共只有五级。

  %      *      /      <<       >>     &(AND)   &^
  +      -      |(OR)  ^(NOT, XOR)
  ==     !=     <      <=       >      >=
  &&
  ||
  

  对于&^更倾向于认为他们是两个操作的叠加，将^解释为单目按位取反操作。逻辑操作&&和||可以更形象比作逻辑乘法和逻辑加法。

  乘除法运算时：若两个参数都是整数，则执行整数运算，否则执行浮点数运算。取模的原则是：结果的符号和被取模的数符号一致。

  算术运算溢出时，高位被丢弃。有符号类型情况比较复杂，如对于int8执行127 + 1得到的结果将是-128。

  不支持运算符重载，另外注意++和--是语句，而不是表达式。按位取反运算采用^算符，而不是C语言中的~算符。

• 语句
  

  对分支语句添加了初始化语句支持，没有?:操作符。

  if init; condition {
          statements
  } else if condition {
          statements
  } else {
          statements
  }
  
  switch expr {
  case value:
          statements
  default:
          statements
  }
  
  switch {
  case condition:
          statements
  default:
          statements
  }
  

  迭代语句range所返回的对象是复制对象，而不是原生对象，当使用引用类型时，底层数据不会被复制。

  Go语言对for语句做了大量重载工作，将原来属于while语句的写法都移植到for语句中了。

  for idx, item := range seqs {           // like for in Python
          statements
  }
  
  for init; condition; post {             // like for in C++
          statements
  }
  
  for condition {                         // like while
          statements
  }
  
  for {                                   // like while(1)
          statements
  }
  

  迭代语句range对不同的序列返回不同：

  string       (i, s[i])
  array/slice  (i, a[i])
  map          (key, m[key])
  channel      e
  

  分支语句switch不再需要写break了，要继续则要显示注明fallthrough。不带表达式的裸swtich语句可以看作是更清爽的if...else if...语句。

  跳转语句break/continue支持带标签形式。

• 函数
  

  函数不支持嵌套、重载和默认参数。但支持匿名函数和闭包。

  变参本质上是切片，只能放于最后。使用切片作为变参时，需要展开为s...。

  多返回值只能用多变量接收，不能用容器对象接收，但是可以直接传递给函数参数。对于命名返回参数，如果被局部变量遮蔽，就需要显式返回。

  func add(x, y int) (z int) {
          {
                  var z = x + y
                  return                  // ERROR: z is shadowed during return
                  return z
          }
  }
  

  命名返回参数支持defer延迟通过闭包修改。

  func add(x, y int) (z int) {
          defer func() {
                  z += 100
          }()
          z = x + y
          return
  }
  

  匿名函数可以在channel中传送。

  fc := make(chan func() string, 2)
  fc <- func() string { return "Hello, World!" }
  println((<-fc)())
  

  多个defer采用FILO顺序执行。延迟调用主要负责释放资源和错误处理。不要滥用defer功能，滥用defer功能容易引发性能问题。

  用panic抛出错误，用recover修复错误。对recover的调用有非常严格的限制，必须在defer函数内直接调用才会终止错误，其它地方调用仅返回nil。

  当匿名函数需要递归调用时，需要先声明变量：

  var visitAll func(items []string)
  visitAll = func(items []string) {
          visitAll(m[item])               // ok
  }
  

  visitAll := func(items []string) {
          visitAll(m[item])               // compile error: undefined: visitAll
  }
  

  在循环中使用匿名函数时要格外小心，下面的问题在于循环变量的作用域，当运行匿名函数时循环已经结束，此时所有线程都是针对最后一个值进行操作：

  var rmdirs []func()
  for _, dir := range tempDirs() {
          os.MkdirAll(dir, 0755)          // ok
          rmdirs = append(rmdirs, func() {
                  os.RemoveAll(dir)       // NOTE: incorrect, dir is the always last one!
          })
  }
  for _, rmdir := range rmdirs {
      rmdir()
  }
  

  正确的操作是：在循环内部声明一个变量，或者定义带参数的匿名函数。

面向对象

• 数据
  

  结构体定义用如下格式：

  type Newtype struct {
          member          Int;
  }
  var temp Newtype;                       // define variable
  

  结构体顺序初始化必须包括全部字段，结构体支持匿名字段，匿名成员的真正用途是提供对基类方法调用的简短写法，因此不要滥用匿名成员。

• 方法
  

  方法只不过多了一个接收对象，可以理解为函数的第一个隐式参数。对于方法的查找，要注意不支持多级指针查找，也就是说想通过多级指针调用方法，就必须显式声明接收对象为多级指针。

  通过匿名字段可以获得和继承类似的复用能力，利用编译器查找次序可以实现重写。

  对方法调用有两种形式：

  instance.method(args...)                // method value
  <type>.func(instance, args...)          // method expression
  

  method value会复制接收对象，下面的代码中，如果Print()的接收对象是指针，将打印修改后的值，如果Print()的接收对象是值，将打印修改前的值。

  func main() {
          u := User{1, "Tom"}
          uprint := u.Print               // copy receiver
          u.id, u.name = 2, "Jack"
          uprint()
  }
  

• 接口
  

  接口本质上就是方法的集合，只要一个类实现了接口中的所有函数，那么就是提供了该接口。如下所示，所有动物都可以定一个Speak()接口。

  type Animal interface {
          Speak() string
  }
  func (c Cat) Speak() string {
          return "Meow!"
  }
  func (j JavaProgrammer) Speak() string {
          return "Design patterns!"
  }
  

标准库

环境工具

go get -u -v github.com/nsf/gocode
go get -u -v github.com/rogpeppe/godef
go get -u -v github.com/golang/lint/golint
go get -u -v golang.org/x/tools/cmd/...

go version                              # 查看版本
go env                                  # 查看环境变量
go list                                 # 列出当前安装的包
godoc -http=:4001                       # 生成本地文档
gofmt -w -s -e .                        # 格式化代码
go get -u -v package                    # 下载并更新包
go tool fix                             # 优化更新老版本代码
go tool vet dirs|files                  # 代码检查
go tool vet -shadow dirs|files          # 检查变量覆盖
go test                                 # 运行测试

依赖管理

import     "sample/test"      // test.A
import  M  "sample/test"      // M.A
import  .  "sample/test"      // A
import  _  "sample/test"      // 仅执行初始化函数

质量管理

func TestAdd1(t *testing.T)
func BenchmarkAdd1(t *testing.T)

func BenchmarkAdd1(b *testing.B) {
        b.StopTimer()
        DoPreparation()
        b.StartTimer()

        for i := 0; i < b.N; i++ {
                Add(1, 2)
        }
}

调试工具

import _ "net/http/pprof"
go http.ListenAndServe("0.0.0.0:8888", nil)

# 收集30s数据
go tool pprof http://IP:PORT/debug/pprof/profile
(pprof) top10                           # CPU占用最多的程序
(pprof) web                             # 生成调用图，需要graphviz
(pprof) help                            # 查看帮助信息

并发编程

func main() {
        data := make(chan int)           // 数据交换队列
        exit := make(chan bool)          // 退出通知
        go func() {
                for d := range data {    // 从队列迭代接收数据，直到 close
                        fmt.Println(d)
                }
                fmt.Println("recv over.")
                exit <- true             // 发出退出通知
        }()
        data <- 1                        // 发送数据
        data <- 2
        data <- 3
        close(data)                      // 关闭队列
        fmt.Println("send over.")
        <-exit                           // 等待退出通知
}

c := make(chan int, 3)
var send chan<- int = c                 // send only
var recv <-chan int = c                 // recv only
send <- 1
<-recv

for {
        select {
        case v, ok = <-a: s = "a"
        case v, ok = <-b: s = "b"
        }
        if ok {
                fmt.Println(s, v)
        } else {
                os.Exit(0)
        }
}

for i := 0; i < 5; i++ {
        select {
        case a <- i:
        case b <- i:
        }
}

睡眠定时

func main() {
        timeChan := time.NewTimer(time.Second).C
        tickChan := time.NewTicker(time.Millisecond * 400).C
        doneChan := make(chan bool)
        go func() {
                time.Sleep(time.Second * 2)
                doneChan <- true
        }()

        for {
                select {
                case <-timeChan:
                        fmt.Println("Timer expired")
                case <-tickChan:
                        fmt.Println("Ticker ticked")
                case <-doneChan:
                        fmt.Println("Done")
                        return
                }
        }
}

client网络连接泄漏

信道关闭准则

程序栈