GO指南

引言

Go

Go语言是谷歌2009发布的编程语言，它是一种并发的、带垃圾回收的、快速编译的语言。

它结合了解释型语言的游刃有余，动态类型语言的开发效率，以及静态类型的安全性。它也打算成为现代的，支持网络与多核计算的语言。要满足这些目标，需要解决一些语言上的问题：一个富有表达能力但轻量级的类型系统，并发与垃圾回收机制，严格的依赖规范等等。这些无法通过库或工具解决好，因此Go也就应运而生了。

优势：

1. 部署简单
   Go 编译生成的是一个静态可执行文件，除了 glibc 外没有其他外部依赖。这让部署变得异常方便：目标机器上只需要一个基础的系统和必要的管理、监控工具，完全不需要操心应用所需的各种包、库的依赖关系，大大减轻了维护的负担。可直接编译成机器码，不依赖其他库，glibc的版本有一定要求，部署就是扔一个文件上去就完成了。

2. 并发性好
   Goroutine 和 channel 使得编写高并发的服务端软件变得相当容易， 很多情况下完全不需要考虑锁机制以及由此带来的各种问题。 单个 Go 应用也能有效的利用多个 CPU 核，并行执行的性能好。

3. 良好的语言设计
   从工程的角度讲，Go 的设计是非常优秀的：规范足够简单灵活，有其他语言基础的程序员都能迅速上手。更重要的是 Go 自带完善的工具链， 大大提高了团队协作的一致性。 比如 gofmt 自动排版 Go 代码， 保证不同人的代码排版风格一致。 此外还有 gofix, govet 等非常有用的工具。

4. 丰富的标准库
   Go目前已经内置了大量的库，特别是网络库非常强大。

5. 执行性能好
   虽然不如 C 和 Java，但通常比原生 Python 应用还是高一个数量级的，适合编写一些瓶颈业务。内存占用也非常省。

适用场景

• 服务器编程，以前你如果使用C或者C++做的那些事情，用Go来做很合适，例如：处理日志、数据打包、虚拟机处理、文件系统等；

• 分布式系统，数据库代理器等；

• 内存数据库，前一段时间google开发的groupcache，couchbase的部分组建；

• 云平台，目前国外很多云平台在采用Go开发，CloudFoundy的部分组建，前VMare的技术总监自己出来搞的apcera云平台。

成功项目

nsq：bitly开源的消息队列系统，性能非常高，目前他们每天处理数十亿条的消息
docker:基于lxc的一个虚拟打包工具，能够实现PAAS平台的组建。
packer:用来生成不同平台的镜像文件，例如VM、vbox、AWS等，作者是vagrant的作者
skynet：分布式调度框架
Doozer：分布式同步工具，类似ZooKeeper
Heka：mazila开源的日志处理系统
cbfs：couchbase开源的分布式文件系统
tsuru：开源的PAAS平台，和SAE实现的功能一模一样
groupcache：memcahe作者写的用于Google下载系统的缓存系统
god：类似redis的缓存系统，但是支持分布式和扩展性
gor：网络流量抓包和重放工具

缺点：

1. Go的import包不支持版本，有时候升级容易导致项目不可运行，需要自己控制相应的版本信息

2. Go的goroutine一旦启动之后，不同的goroutine之间切换不是受程序控制，runtime调度的时候，需要严谨的逻辑，不然goroutine休眠，过一段时间逻辑结束了，突然冒出来又执行了，会导致逻辑出错等情况。

3. GC延迟有点大，并发很大的情况下，处理很大的日志，GC 没有那么快，内存回收不给力，后来经过 profile 程序改进之后得到了改善。

为何没流行？

• 没什么太多应用场景非要 Golang 才能做的 ( Golang 最大特点是异步和单进程跑多核 )
• 开发 web 没有 php ruby 成熟、快速、人好招
• 开发 server 没有 java 现成解决方案多

---

GO指南

环境搭建

安装Golang的SDK

(1) http://www.golangtc.com/download
(2) 安装完成之后，打开终端，输入go、或者go version查看安装版本

配置Go环境变量GOPATH和GOBIN

　　（1）打开终端，cd ~

　　（2）查看是否有.bash_profile文件：

　　　　 ls -all

　　（3）有则跳过此步，没有则：

　　　　1）创建：touch .bash_profile

　　　　2）编辑：open -e .bash_profile

　　　　3）自定义GOPATH和GOBIN位置：

        GOPATH:日常开发的根目录。GOBIN:是GOPATH下的bin目录。

        export GOPATH=/Users/yuan/go
        export GOBIN=$GOPATH/bin
        export PATH=$PATH:$GOBIN

　　（4）编译：source .bash_profile

　　（5）*查看Go环境变量：go env
　　

开发工具配置

sublime text

一定要先配置好Go环境变量GOPATH和GOBIN，再安装此插件，要不插件会提示找不到GOPATH和GOBIN；

选用 sublime text 安装 gosublime 插件进行开发（ golang 语法高亮提示）

　　（1）安装 package controll（若已安装，请跳过）
　　使用Ctrl+`快捷键或者通过View->Show Console菜单打开命令行，粘贴如下代码：

import urllib.request,os; pf = 'Package Control.sublime-package'; ipp = sublime.installed_packages_path(); urllib.request.install_opener( urllib.request.build_opener( urllib.request.ProxyHandler()) ); open(os.path.join(ipp, pf), 'wb').write(urllib.request.urlopen( 'http://sublime.wbond.net/' + pf.replace(' ','%20')).read()) 2

　　（2）install go sublime
Command+shift+p 输入并选择packageControl: install package
然后输入并选择goSublime
安装完成就OK啦~~

Gogland

选择Gogland, 下载安装即可，3个月
    https://www.jetbrains.com/go/download/

LiteIDE

    国产IDE    
    http://golangtc.com/download/liteide

小试牛刀

在你的gopath目录下，新建main.go文件即可以进行编码了。

package main
import (
    "fmt"
)
func main() {
    fmt.Println("hello gopher~");
}

代码编写完成之后,使用command＋b打开sublime text终端

（一）编译+执行
使用go build main.go对其进行编译,编译通过的结果信息如下:

[ go build main.go | done: 420.495985ms ]
提示编译成功之后，再执行shell命令，执行刚刚编译之后的文件./main即可看到运行结果:

[ ./main | done: 10.532868ms ]
hello go

（二）直接执行
如果仅仅是只需要看到运行的结果，而不产生可执行文件(文件名和项目名一样)则在sublime text终端中直接使用go run xxx.go即可:

[ go run main.go | done: 314.476988ms ]
hello go

基础

包、变量、函数

package main

import "fmt"

func main() {
    var hello string = "Hello"
    who := "gopher"
    var s = hello+"," + who
    fmt.Println(s)
}

包

1. 每个 Go 程序都是由包组成的。
2. 程序运行的入口是包 main 。
3. 按照惯例，包名与导入路径的最后一个目录一致。例如，”math/rand” 包由 package rand 语句开始。

变量

• 变量声明使用关键字var
• 初始值存在时可省略类型声明
• 短赋值语句:= 可以用于替代 var 的隐式类型声明（:=结构不能使用在函数外，函数外的每个语法块都必须以关键字开始）

var name1 string //声明变量
name1 = "tom" //给变量赋值
var name2 string = "tom" //声明变量+赋值
var name3 = "tom" // 声明时同时赋值，可以省略变量类型
name4 := "tom" //短赋值语句

// 多个变量
var x, y, z int
var c, python, java bool

var x, y, z int = 1, 2, 3
var c, python, java = true, false, "no!"

c, python, java := true, false, "no!"

函数

• 可以返回任意数量的返回值
• 类型声明在变量名之后
• 同一类型的多个参数，最后一个参数需声明类型

func swap(x, y string) (string, string) {
    return y, x
}

• 命名返回值的参数

func split(sum int) (x, y int) {
    x = sum * 4/9
    y = sum - x
    return
}

基本类型

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
     // 代表一个Unicode码位

float32 float64

complex64 complex128

常量

const Pi = 3.14
const World = "世界"
const Truth = true

运算符

http://www.yiibai.com/go/go_operators.html

注意：

• 没有++i，–i，只有i++、i–
• 不能使用i++、i–对变量直接赋值

流程控制

for

Go 只有一种循环结构—— for 循环

for i := 0; i < 10; i++ {
    //do something
}

i := 0
for ; i < 1000; {
    //do something
}
for i < 1000 {
    //do something
} 
for {
    //死循环
}

if else

if x < 0 {
    return x
}

if v := 0; v < 5 {
    return v
}
return 9

switch

case 语句匹配后会自动终止(无需break)，除非用 fallthrough 语句作为结尾，则会强制执行下一条case的语句或者default语句，而不判断expression。

    x := 2
    switch x {
    case 1:
        fmt.Println(1)
    case 2:
        fmt.Println(2)
        fallthrough
    case 3:
        fmt.Println(x > 1)
    default:
        fmt.Println("default")
    }

// 结果
// 2
// true

defer

延迟(defer)处理
Defer用于确保在稍后的程序中，执行函数调用。
defer语句在封装函数(main)结束时执行。

package main

import "fmt"
import "os"

func main() {
    f := createFile("defer-test.txt")
    defer closeFile(f)
    writeFile(f)
}

func createFile(p string) *os.File {
    fmt.Println("creating")
    f, err := os.Create(p)
    if err != nil {
        panic(err)
    }
    return f
}

func writeFile(f *os.File) {
    fmt.Println("writing")
    fmt.Fprintln(f, "data")
}

func closeFile(f *os.File) {
    fmt.Println("closing")
    f.Close()
}


// output

  creating
  writing
  closing

复杂类型

struct

要定义结构，必须使用type和struct语句。struct语句定义了一个新的数据类型，在程序中有多个成员。type语句在例子中绑定一个类型为struct的名字。 struct语句的格式如下：

type person struct {
    name string
    age  int
}

访问结构体成员使 .

package main

import "fmt"


type person struct {
    name string
    age  int
}

func main() {

    fmt.Println(person{"Bob", 20})
    fmt.Println(person{name: "Alice", age: 30})
    fmt.Println(person{name: "Fred"})
    fmt.Println(&person{name: "Ann", age: 40})
    s := person{name: "Sean", age: 50}
    fmt.Println(s.name)
    sp := &s
    fmt.Println(sp.age)
    sp.age = 51
    fmt.Println(sp.age)
}

#output
{Bob 20}
{Alice 30}
{Fred 0}
&{Ann 40}
Sean
50
51

slice

因为切片(Slice)是数组上的抽象。 它实际上使用数组作为底层结构体.len()函数返回切片中存在的元素数量，其中cap()函数返回切片(Slice)的容量(大小)，即可容纳多少个元素。

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

//output
len=3 cap=5 slice=[0 0 0]

map

var map_variable map[key_data_type]value_data_type
map_variable = make(map[key_data_type]value_data_type)

map_variable := make(map[key_data_type]value_data_type)

delete(map_variable, key)

package main

import "fmt"

func main() {
    var countryCapitalMap map[string]string = make(map[string]string)
    /* create a map*/
    // countryCapitalMap = make(map[string]string)

    /* insert key-value pairs in the map*/
    countryCapitalMap["France"] = "Paris"
    countryCapitalMap["Italy"] = "Rome"
    countryCapitalMap["Japan"] = "Tokyo"
    countryCapitalMap["India"] = "New Delhi"

    /* print map using keys*/
    for country := range countryCapitalMap {
        fmt.Println("Capital of", country, "is", countryCapitalMap[country])
    }

    /* test if entry is present in the map or not*/
    capital, ok := countryCapitalMap["United States"]
    /* if ok is true, entry is present otherwise entry is absent*/
    if ok {
        fmt.Println("Capital of United States is", capital)
    } else {
        fmt.Println("Capital of United States is not present")
    }
    /* delete an entry */
    delete(countryCapitalMap, "France")
    fmt.Println("Entry for France is deleted")

    fmt.Println("Updated map")

    /* print map */
    for country := range countryCapitalMap {
        fmt.Println("Capital of", country, "is", countryCapitalMap[country])
    }
}

range

package main

import "fmt"

func main() {

    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    for k := range kvs {
        fmt.Println("key:", k)
    }

}

方法和接口

方法

package main

import "fmt"

type rect struct {
    width, height int
}

func (r *rect) area() int {
    return r.width * r.height
}

func (r rect) perim() int {
    return 2*r.width + 2*r.height
}
func main() {
    r := rect{width: 10, height: 5}

    fmt.Println("area: ", r.area())
    fmt.Println("perim:", r.perim())

    rp := &r
    fmt.Println("area: ", rp.area())
    fmt.Println("perim:", rp.perim())
}

// output
  area:  50
  perim: 30
  area:  50
  perim: 30

接口

package main

import "fmt"
import "math"

type geometry interface {
    area() float64
    perim() float64
}

type rect struct {
    width, height float64
}
type circle struct {
    radius float64
}

func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}
func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    measure(r)
    measure(c)
}

// output
  {3 4}
  12
  14
  {5}
  78.53981633974483
  31.41592653589793

并发

goroutine

package main
import "fmt"
func f(from string) {
    for i := 0; i < 3; i++ {
        fmt.Println(from, ":", i)
    }
}

func main() {

    f("direct")
    go f("goroutine")

    go func(msg string) {
        fmt.Println(msg)
    }("going")

    var input string
    fmt.Scanln(&input)
    fmt.Println("done")
}

// output
$ go run goroutines.go
direct : 0
direct : 1
direct : 2
goroutine : 0
going
goroutine : 1
goroutine : 2
<enter>
done

channel

channel 是有类型的管道，可以用 channel 操作符 <- 对其发送或者接收值。

ch <- v // 将 v 送入 channel ch。
v := <-ch // 从 ch 接收，并且赋值给 v。

默认情况下，在另一端准备好之前，发送和接收都会阻塞。这使得 goroutine 可以在没有明确的锁或竞态变量的情况下进行同步。

package main
import "fmt"
func main() {

    messages := make(chan string)

    go func() { messages <- "ping" }()

    msg := <-messages
    fmt.Println(msg)
}

channel 可以是带缓冲的。为 make 提供第二个参数作为缓冲长度来初始化一个缓冲 channel：

ch := make(chan int, 100)
向缓冲 channel 发送数据的时候，只有在缓冲区满的时候才会阻塞。当缓冲区清空的时候接受阻塞。

package main

import "fmt"

func main() {
    c := make(chan int, 2)
    c <- 1
    c <- 2
    fmt.Println(<-c)
    fmt.Println(<-c)
}

close

发送者可以 close 一个 channel 来表示再没有值会被发送了。接收者可以通过赋值语句的第二参数来测试 channel 是否被关闭：当没有值可以接收并且 channel 已经被关闭，那么

v, ok := <-ch
ok 会被设置为 false。

注意： 只有发送者才能关闭 channel，而不是接收者。向一个已经关闭的 channel 发送数据会引起 panic。

package main

import "fmt"

func main() {
    jobs := make(chan int, 5)
    done := make(chan bool)

    go func() {
        for {
            j, more := <-jobs
            if more {
                fmt.Println("received job", j)
            } else {
                fmt.Println("received all jobs")
                done <- true
                return
            }
        }
    }()

    for j := 1; j <= 3; j++ {
        jobs <- j
        fmt.Println("sent job", j)
    }
    close(jobs)

    fmt.Println("sent all jobs")

    <-done
}

select

Go语言的选择(select)可等待多个通道操作。将goroutine和channel与select结合是Go语言的一个强大功能。

select 会阻塞，直到条件分支中的某个可以继续执行，这时就会执行那个条件分支。如果有多个都准备好的时候，会随机选一个。

package main

import "time"
import "fmt"

func main() {
    c1 := make(chan string)
    c2 := make(chan string)
    c3 := make(chan string)

    t1 := time.Now().UnixNano()

    go func() {
        time.Sleep(time.Second * 1)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "two"
    }()

    go func() {
        time.Sleep(time.Second * 2)
        c3 <- "three"
    }()

    for i := 0; i < 3; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        case msg3 := <-c3:
            fmt.Println("received", msg3)
        }
    }
    t2 := time.Now().UnixNano()
    dt := (t2 - t1) / 1e6
    fmt.Println(dt)

}

实战

函数闭包

函数是完全闭包的。

package main

import "fmt"
// 函数 adder 返回一个闭包。每个闭包被绑定到自己的 sum 变量上
func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {
    pos, neg := adder(), adder()
    for i := 0; i < 10; i++ {
        fmt.Println(
            pos(i),
            neg(-2*i),
        )
    }
}

error

Go编程提供了一个非常简单的错误处理框架，以及内置的错误接口类型，如下声明：

type error interface {
   Error() string
}

Go函数通常返回错误作为最后一个返回值。 可使用errors.New来构造一个基本的错误消息

package main

import "errors"
import "fmt"
import "math"

func Sqrt(value float64)(float64, error) {
   if(value < 0){
      return 0, errors.New("Math: negative number passed to Sqrt")
   }
   return math.Sqrt(value), nil
}

func main() {
   result, err:= Sqrt(-1)

   if err != nil {
      fmt.Println(err)
   }else {
      fmt.Println(result)
   }

   result, err = Sqrt(9)

   if err != nil {
      fmt.Println(err)
   }else {
      fmt.Println(result)
   }
}

---

开发陷阱

开大括号不能放在单独的一行
未使用的变量
未使用的Imports
不支持前置版本的自增和自减，也无法在表达式中使用这两个操作符。
。。。

50坑
http://studygolang.com/articles/8382

---

Reference:
1. http://gotour.qizhanming.com/#1
2. https://tour.go-zh.org/basics/1
3. http://www.yiibai.com/go/go_start.html
4. https://www.zhihu.com/question/21409296
5. https://gobyexample.com/