Go 手册

终于有应用场景需要用到Go了,这次算是正式开始学了。其实在我眼里,Go的应用场景主要有以下几点

  • 超高并发/超高性能
  • 多核CPU充分利用
  • 系统底层应用开发

其实自己的项目或者现在公司的项目,都配不上”超高”两字,所以也就没考虑过用Go语言,而是用能快速开发的PythonPHP

安装Go

需要注意的是,在使用go之前,必须设置GOPATH这个环境变量,并且该环境变量不允许和GOROOT一样,该目录是用来存放第三方包的源码的地方。

1
2


编译与构建

如果是一个单独的文件运行程序,那么该文件的package必须是package main,否则会出现go run: cannot run non-main package错误

基本语法

变量

  • 基本的变量类型有bool/string/int/int8/int16/int32/int64/uint/uint8/uint16/uint32/uint64/unitptr/float32/float64/complex64/complex128(其中uint8=byteint32=rune)
  • 如果是在块中定义的变量(例如if for等),作用于仅仅在块中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
var a, b bool	// var声明变量,必须在后面指定类型。而且会给一个默认值
var c, d int = 1, 2
e := 3 // 不用var直接声明并赋值
const f = 4 // 声明常量
_, err := function() // 表示第一个返回值后面不会被使用,这样可以防止出现"declared and not used"提示

reflect.TypeOf(b) // 获取变量类型

// 指针
var p *int // 定义p是一个指向int类型值的指针,默认值为nil
p = &a // 取a的指针
*p // 取值

// 结构体
type Vertex struct {
x int
y int
}
v = Vertex{1, 2}
v.x

// 给结构体定义方法,类似于类
func (v Vertex) Abs() float64{
return math.Sqrt(v.X*v.Y)
}
v.Abs() // 就可以这样调用了

// 接口,就是由一组方法签名定义的集合
type Abser interface {
Abs() float64
}

数字/整型/布尔值

  • 布尔值的默认值为false
  • 由于int类型的范围,与平台有关,所以在长度不确定的时候,最好使用int64
1
2
3
4
5
6
7
string:=strconv.Itoa(int)	// 整型转换为字符串
string:=strconv.FormatInt(int64,10) // int64转换为字符串
myInt := int64(normalInt) // int转换为int64

// 产生随机数
rand.Seed(time.Now().Unix()) // 初始化随机种子
rand.Intn(len(proxies))

数组slice

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var g [10]int	// 声明g为一个包含10个int的数组
h := [3]int{1,2,3} // 这个定义语法也是...唉
i := []int{1,2,3}
h[low : high] // 居然能切片,需要注意的是,切片之后并不是新建变量,而只是原数组的部分引用,修改切片后的值会影响原数组
len(h) // 切片的元素数量
cap(h) // 切片的容量。从切片的第一个元素到底层数组的末尾元素的元素数量
j := make([]int, 5) // make 函数会分配一个元素为零值的数组并返回一个引用了它的切片
l := make([]int, len(...))
k := make([]int, 0, 5) // len(k)=0, cap(k)=5
k = append(k, 1) // 向切片增加元素

// 动态数组/不定长数组
var arr []string
newArr = append(arr, "one")

字符串/json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
str = `定义超长的字符串`
if str == "" {} // 判断字符串是否为空
fmt.Sprintf("%s %d", "abc", 1) // 字符串格式化

int,err:=strconv.Atoi(string) // 字符串转换为int类型
int64, err := strconv.ParseInt(string, 10, 64) // 字符串转换为指定类型指定进制的整型
arr := []byte(str) // 将字符串直接转换为字节数组

// 字符串查找
strings.Contains("seafood", "foo") // 字符串是否包含某个子字符串
strings.Count("abc", "a") // 子字符串在字符串中出现的次数
strings.HasPrefix("Gopher", "Go") // 字符串开头
strings.HasSuffix("Amigo", "go") // 字符串结尾

// 字符串分割
strings.Split("foo,bar,baz", ",") // ["foo" "bar" "baz"]
strings.SplitAfter("foo,bar,baz", ",") // ["foo," "bar," "baz"]
strings.SplitN("foo,bar,baz", ",", 2) // ["foo", "bar,baz"]

// 正则表达式
reg := regexp.MustCompile(`"page":(\d)`) // 定义规则
match := reg.FindStringSubmatch(text) // 获取满足条件的子字符串,match[1]表示括号中的,这里只匹配第一次,FindAllStringSubmatch表示查找所有

结构体/类/接口

  • go语言本身没有类的概念,但是可以用结构体来实现一个类。

  • 判断结构体是否为空,可以直接判断里面的某个字段是否为空,或者,新建一个空结构体,例如(Option{}) == option

  • 结构体中属性开头字母如果大写,表示可以在其他包中访问,否则只能在本包中访问。这个地方需要特别注意的是,像使用json.Marshal类似的操作,也是访问不到小写开头属性的,因为json算是另外一个包了

  • 接口interface类似于基类或者接口类,定义一些公有的方法然后继承者去实现

  • 空接口类型interface{}可以存储任意数据类型的实例,如果用于函数参数表示该函数接收任意的数据类型

  • 由于有些函数确定了入参类型,但是接口又代表的是所有类型,所以如果要把一个接口传入一个明确类型的函数中,就需要特别指明其类型。例如function(var.(string)。不过这不能作用于接口数组,否则会出现invalid type assertion non-interface type []... on left这样的错误,如果要传入一个数组,需要我们构建一下参考:

    1
    2
    3
    4
    5
    6
    s := make([]interface{}, len(t))
    for i, v := range t {
    s[i] = v
    }

    function(s) // function([] interface{})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// 创建匿名结构体
var book struct{Name string}
json.Marshal(struct{Name string, year int}{"name", 2018}) // 这种方式可以在创建的时候初始化值

// 结构体转json格式字符串
b, err := json
if err != nil {}
str := string(b)

// json格式字符串转结构体使用tag来定义序列化时的字符串名称,例如
type Book struct{
Name string `json:"name" bson:"NAME"`
}
var book Book
jsonStr := `{"Name": "haofly"}`
json.Unmarshal([]byte(jsonStr), &book)
fmt.Println(book)

// 继承/组合结构体
type Option2 struct {
Option
ip string
}

// 可以自己在当前package里面写一个函数来当作构造函数,例如
func NewOption(arg Args) (Option, error) {
return Option{}
}

// 实例化的几种方法
var opt Option; // 变量声明
opt.proxy = "" // 给字段复制
opt := Option{}
opt := &Option{}
opt := &Option{proxy: ""}
opt := Option{proxy: ""}
opt := new(Option)

// 在定义完结构提后,可以这样声明类的方法
func (option *Option) get() {...}

映射map/字典

1
2
3
4
5
6
7
8
9
// 变量映射,额,跟字典超级像呀
var m map[string]Vertex
m = make(map[string]Vertex)
m["test"] = Vertex{10, 20}
delete(m, key) // 删除元素

for key, value := range m {
log.Info(key, value)
}

控制语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// if语句
if x < 0 {}
if x <0 && y > 0 {}
if v := match.Pow(x, n); v < lim {} // 一边if一边声明变量,该变量只有在该作用域有效

// for 循环
for i := 0; i < 10; i++ {}
for ; sum < 1000; {} // 可以直接不写前后条件
for sum < 1000 {} // while循环
for {} // while true循环
for i,v := range pow {} // pow是一个切片,for循环遍历切片时,每次迭代都会返回两个值,第一个是下标,第二个是元素

// switch,不需要在case后面加break
switch os := os; os {
case "darwin":
...
default:
...
}
switch {
case t.Hour() < 12: // 没错,可以这样写条件。反正都是从上往下,匹配到第一个就终止。其他语言为啥不这样
...
}

函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// defer语句会将语句推迟到外层函数返回之后执行,相当于finally,类似析构函数,例如
defer resp.Body.Close()

// return后面不跟参数可以直接返回定义了的变量名
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}

// 定义返回带异常的函数,相当于将内部的err抛出来
func my(a int) (string, error) {
return "123", nil
}

// 定义不确定变量数量的函数/可选参数
func test(v ...interface{}) {
fmt.Println(v) // 是一个切片/数组
fmt.Println(v[0])
fmt.Println(v[1].(string)) // 在使用的时候声明该变量类型
}

错误处理

通常函数都会返回一个error值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
re, err := Abs()
if err != nil {errString := err.Error()} // 得到错误的message

if re, err := Abs(); err != nil {} // 直接在一行进行错误处理

errors.New("redis not connectetd") // 新建一个error

// 聚合处理error
var err error
defer func() {
if err != nil {
handle()
}
}()
//这样当有错误出现的时候不用单独写handle函数,所有错误同样处理
err = doSomeThing()
if err != nil {return}

go协程-go程

Go的协程居然就叫go。select语句让go可以等待多个通信操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
go f(x,y,z)	// 这样会启动一个新的协程去处理f函数

// select使一个Go程可以等待多个通信操作。select 会阻塞到某个分支可以继续执行为止,这时就会执行该分支。当多个分支都准备好时会随机选择一个执行。
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)

// 锁sync.Mutex

信道

信道是带有类型的管道,你可以通过它用信道操作符 <- 来发送或者接收值。看起来非常有用。信道的发送和接收操作在另一端准备好之前都会阻塞,相当于发送信道方在其他协程从信道读取数据之前会被阻塞,而接收信道方在其他协程发送之前会被阻塞。可用于在其他协程结束之前,阻塞Go主协程。

1
2
3
4
5
6
7
8
9
10
ch := make(chan int)	// 定义一个信道,其中的值类型为int
ch := make(chan int, 100) // 带缓冲区的信道,仅当信道的缓冲区填满后,向其发送数据时才会阻塞。当缓冲区为空时,接受方会阻塞
close(ch) // 主动关闭信道
ch <- v // 将v发送到信道ch
v := <-ch // 从ch接收值

// 这样可以不断从信道取数据,信道关闭后自动退出,但是信道如果没有主动关闭,会一直等待,其中i就是信道发送过来的值
for i: = range ch {
// 虽然不能直接在这里面close(ch),但是可以通过判断来break,在循环break之后close信道呀
}

文件操作

1
2
3
b, err := ioutil.ReadFile("test.json")	// 直接读取文件内容
if err != nil {}
str := string(b) // 将文件内容转换为字符串

包管理

引用包里面的变量,必须是已经导出的,只有大写开头的才是导出的,例如math.Pi

1
2
3
4
5
6
7
// 定义当前包名
package main
// 导入包
import (
"fmt"
"math"
)

标准库

网络请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import "net/http"
// GET请求
resp, err := http.Get("https://haofly.net")
if err != nil {}
defer resp.Body.Close() // 必须关闭连接
body, err := ioutil.ReadAll(resp.Body)
if err != nil {}
fmt.Println(string(body))

// POST请求
http.Post('url', "application/x-www-form-urlencoded", strings.NewReader("name=test"))
http.PostForm('url', url.Values{"key": {"value"}})

// 复杂的http请求用client,例如设置header头以及cookie
client := &http.Client{
Transport: &http.Transport{
http.ProxyURL(proxyURL) // 设置代理
},
Timeout: time.Second * 300, // 设置超时时间
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return errors.New("something bad happened") // 设置重定向处理逻辑
},
}

// 设置header头,需要注意的是client和这里的request是不同的两个概念,不能在client层面设置header头
req, err := http.NewRequest("POST", "url")
if err != nil {}
req.Header.Set("Content-Type", "")
req.Header.Set("Cookie", "name=test")
resp, err := client.Do(req)

// http编码转换(gbk转utf8),使用标准库golang.org/x/net/html/charset
contentType := resp.Header.Get("Content-Type")
utf8reader, err := charset.NewReader(resp.Body, contentType)
if err != nil {}
text, err := ioutil.ReadAll(utf8reader)
if err != nil {}
return string(text), nil

时间处理

1
2
3
import time
start := time.Now() // 获取当前时间,格式虽然不大懂,但是时间运算是相当强的
start - time.Now() // 计算时间差,自带单位换算,而且非常精准

扩展库推荐

基本上可以理解为gopkg.in才是Go官方推荐的库网站,地址与github中的地址其实是相对应的,不过这个好处是可以在后面加一个版本号做到版本控制

  • gjson: 非常好用的redis数据读取库(仅仅是读)
  • logrus: 日志库,默认日志级别为InfoDebug级别需要主动设置
  • mgo: mongo驱动
  • redigo: redis驱动

TroubleShooting

  • should have comment or be unexported,这只是VSCode的语法Warning,它希望暴露的结构体等有一个明确的注释,这时候只需要在需要注释的结构体上面加上这样的注释即可:

    1
    2
    // test is ...
    type test struct {}
扩展阅读

官方FAQ: 我见过写得最详细的编程语言官方FAQ

haofly wechat
欢迎您扫一扫上面的微信公众号,订阅我的博客!
坚持原创技术分享,您的支持将鼓励我继续创作!
  • 本文作者: haofly
  • 本文链接: https://haofly.net/go/
  • 版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明出处!