Go入门-Go语言从入门到进阶实战

发表于 更新于 分类于 ， 阅读次数： 本文字数： 11k 阅读时长 ≈ 10 分钟

1. 开始学习Go

从一本书开始，这本书叫做《Go语言从入门到进阶实战（视频教学版）》,当然这篇Blog并不是所有的内容都来自这本书，毕竟书中也有不足之处。

2. Hello World

学啥语言的第一步都是Hello World, 第一步是搭建开发环境，直接下载Goland，创建一个新的工程，点击create

建好项目以后，项目应该是下面这个样子的，当然我们不用关注这个go.mod是干什么的，我们只是利用IDE编写代码，使用命令行运行。

1
2
3
4
5
6
s@HELLOWANG-MB1 go-study % tree
.
`-- go.mod

0 directories, 1 file

然后新建一个main.go的文件，其内容如下

1
2
3
4
5
package main
import "fmt"
func main() {
    fmt.Println("hello world")
}

最后运行该文件

1
2
s@HELLOWANG-MB1 go-study % go run main.go
hello world

我们也可以编译为二进制文件，然后运行

1
2
3
4
5
s@HELLOWANG-MB1 go-study % go build main.go
s@HELLOWANG-MB1 go-study % ls
go.mod  main    main.go
s@HELLOWANG-MB1 go-study % ./main
hello world

3. Go的变量声明

变量的声明方式为var <变量名> <变量类型>

例如下面的程序

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
    var a int // 定义一个整形
    fmt.Println(a)
}

经过了命令行运行以后，可以转而使用IDE集成开发，点击按钮▶️

当然，还有更多的声明方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import "fmt"

func main() {
    var a int // 定义一个整形
    fmt.Println(a)

    var b int = 1 // 定义并赋值
    fmt.Println(b)

    var c = 2 // 编译器自动推导
    fmt.Println(c)

    d := 3 // 精简写法
    fmt.Println(d)
}

最后还有一个小技巧，即函数返回可以是多个变量，用逗号分隔, _表示匿名变量，即忽略该位置的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
    a := 1
    b := 2
    a, b = b, a
    c, _ := a, b
    _, d := a, b
    fmt.Println(a, b, c, d)
}

4. Go 的基础数据类型

4.1. 整形

有符号整型: int8 int16 int32 int64

无符号整型: uint8 uint16 uint32 uint64

平台自适应整形: int uint(自动根据平台决定整形的长度)

4.2. 浮点数

float32 float64

1
2
3
4
5
6
7
8
9
10
package main

import "fmt"

func main() {
    var a float32 = 1.5
    var b float64 = 1.5
    fmt.Println(a, b)
}

4.3. 布尔型

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
    var a bool = true
    fmt.Println(a)
}

4.4. 字符串

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
    var a string = "123"
    fmt.Println(a)
}

多行字符串

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
    var a string = `  123你好
    abcsdaf
aslfnskflasjlfjoiwn
    `
    fmt.Println(a)
}

5. Go的控制流

5.1. 循环

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
package main

import "fmt"

func main() {

    // 类似与C的while
    a := 1
    for a <= 3 {
        fmt.Println(a)
        a++
    }

    // 类似与C的while(true)
    for {
        fmt.Println("break")
        break
    }

    // 类似于C的for
    for i := 0; i < 3; i++ {
        fmt.Println("hello")
    }

}

5.2. 条件判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {

    if 1+1 == 2 {
        fmt.Println("1+1=2")
    } else {
        fmt.Println("1+1!=2")
    }

}

5.3. switch

需要注意的是Go的switch自带break，下面的程序只会输出3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import "fmt"

func main() {

    switch 3 {
    case 3:
        fmt.Println(3)
    case 2:
        fmt.Println(2)
    case 1:
        fmt.Println(1)
    }

}

6. Go的容器/集合

6.1. Map

注意map需要指定key和value 的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
    mp := make(map[string]int)
    mp["k1"] = 1
    mp["k2"] = 2
    fmt.Println(mp)

    delete(mp,"k1")
    fmt.Println(mp)
    
}

6.2. 数组

数组长度固定, 创建数组也有很多种写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
    var arr1 []int = make([]int, 3)
    arr1[0] = 1

    arr2 := [3]int{1, 2}
    arr3 := [...]int{1, 2}

    fmt.Println(arr1, arr2, arr3)
}
// [1 0 0] [1 2 0] [1 2]

注意对于由字面量组成的数组，如果长度小于等于4，那么它将直接被分配到栈上，否则分配到静态区

6.3. 切片

切片的创建可以是数组的一部分，也可以直接创建，切片可扩容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import "fmt"

func main() {
    var arr1 []int = make([]int, 3) // 数组

    slice1 := arr1[1:2]
    slice2 := []int{1, 2, 3}
    slice3 := make([]int, 3)

    fmt.Println(slice1, slice2, slice3)
}

// [0] [1 2 3] [0 0 0]

那么切片和数组有什么区别呢？其实切片只是数组的一个引用，任何一个切片，其背后一定有一个数组，当切片进行扩容的时候，会根据数组的剩余空间大小来决定附身到新的数组上，或者直接在原数组上扩容切片。

具体表现如下, 输出就在注释里面。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import "fmt"

func main() {
    arr1 := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

    slice1 := arr1[2:5]
    slice2 := arr1[3:6]

    fmt.Println(slice1, slice2)
    arr1[4]=0
    fmt.Println(slice1, slice2)
}

// [2 3 4] [3 4 5]
// [2 3 0] [3 0 5]

6.3. 列表

列表可以自动伸缩

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import (
    "container/list"
    "fmt"
)

func main() {
    ls := list.New()
    ls.PushBack(1)
    ls.PushBack(2)
    fmt.Println(ls)
}

7. Go的函数

返回值写在参数后面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func plus(a int, b int) int {
    return a + b
}

func main() {
    a := 1
    b := 1
    fmt.Println(plus(a, b))
}

还可以选择返回多个值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func swap(a int, b int) (int, int) {
    return b, a
}

func main() {
    a := 1
    b := 2
    fmt.Println(swap(a, b))
}

变长的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func sum(a ...int) int {
    s := 0
    for i := 0; i < len(a); i++ {
        s += a[i]
    }
    return s
}

func main() {
    fmt.Println(sum(1, 2, 3))

    nums := []int{1, 2, 3, 4}
    fmt.Println(sum(nums...))
}

返回一个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

func increase() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

func main() {
    fun := increase()
    fmt.Println(fun())
    fmt.Println(fun())
    fmt.Println(fun())
    fmt.Println(fun())

}

8. Go的指针

和C一样

9. Go 的结构体

9.1. 结构体定义

1
2
3
4
5
type <类型名> struct {
    <字段1名> <字段1类型>
    <字段2名> <字段2类型>
    <字段3名> <字段3类型>
}

例子:

1
2
3
4
type Point struct {
    X int32
    Y int32
}

9.2. 结构体实例化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import "fmt"

type Point struct {
    X int32
    Y int32
}

func main() {
    var p Point
    p.X = 1
    p.Y = 2
    fmt.Println(p.X, p.Y)
}

使用new实例化,注意此时得到的p2是指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

type Point struct {
    X int32
    Y int32
}

func main() {
    p2 := new(Point)
    fmt.Println(p2)
}

9.3. 结构体函数

结构体函数定义比普通函数定义在func和函数名之间多了一个结构体对象，这个对象一般使用指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

type Point struct {
    X int32
    Y int32
}

func (p *Point) getAndSet(X int32, Y int32) (int32, int32) {
    p.X, X = X, p.X // swap
    p.Y, Y = Y, p.Y // swap
    return X, Y
}

func main() {
    p := new(Point)
    p.X, p.Y = 1, 2
    fmt.Println(p.getAndSet(3, 4))
    fmt.Println(p.X, p.Y)
}


9.4. 结构体的Tag

结构体中的字段可以设置Tag，即给字段打上标签，就像Java中的注解一样。然后可以使用一种比较高级的技术（反射来获取这个标签）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import "reflect"

type Point struct {
    X int `name:"XXX" X:"你好"`
    Y int `name:"YYY"`
}

func main() {
    p := &Point{
        X: 1,
        Y: 2,
    }

    field, _ := reflect.TypeOf(*p).FieldByName("X")

    println(field.Tag)
}
// 输出:
// name:"XXX" X:"你好"asdf

10. Go的接口

接口定义

1
2
3
4
type <接口类型名> interface{
    <方法1名> (<参数列表1>) 返回值列表1
    <方法2名> (<参数列表2>) 返回值列表2
}

让结构体实现接口, 只需要让结构体的函数与接口保持一致即可，

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
package main

import "fmt"

type Point struct {
    X int32
    Y int32
}

type GetAndSet interface {
    invoke(X int32, Y int32) (int32, int32)
}

func (p *Point) invoke(X int32, Y int32) (int32, int32) {
    p.X, X = X, p.X // swap
    p.Y, Y = Y, p.Y // swap
    return X, Y
}

func main() {
    p := new(Point)
    p.X, p.Y = 1, 2

    var it GetAndSet = p
    fmt.Println(it.invoke(3, 4))
    fmt.Println(p.X, p.Y)
}

11. Go的包

回到最开始的Helloworld，注意到第一行中的package main， 在Go中，有这样一个约定

包名为main的包为应用程序的入口包，编译源码没有main包时，将无法编译输出可执行的文件。

1
2
3
4
5
package main
import "fmt"
func main() {
    fmt.Println("hello world")
}

11.1. Go的包导出

在Go中，首字母为小写的变量只能在包内使用，首字母为大写的变量会自动导出，可以在其他包使用。

这是第一个文件mylib/mylib.go

1
2
3
4
5
6
7
8
9
10
package mylib

func Add(a, b int32) int32 {
    return a + b
}

func add(a, b int32) int32 {
    return a + b
}

11.2. Go的包导入

然后是main.go, 注意到可以直接使用Add函数，但是不能使用add函数

1
2
3
4
5
6
7
8
9
10
11
12
package main

import (
    "fmt"
    "go-study/mylib"
)

func main() {
    var a, b int32 = 1, 2
    fmt.Println(mylib.Add(a, b))
}

在导入的时候可以直接重命名，只需要在包名前加上一个名字即可

1
2
3
4
5
6
7
8
9
10
11
package main

import (
    "fmt"
    lb "go-study/mylib"
)

func main() {
    var a, b int32 = 1, 2
    fmt.Println(lb.Add(a, b))
}

11.3. Go的包的init函数

一个包的init函数在包被引入时自动调用, 对于main包，init函数在main函数前运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package mylib

import "fmt"

func Add(a, b int32) int32 {
    return a + b
}

func add(a, b int32) int32 {
    return a + b
}

func init(){
    fmt.Println("hi")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
    "fmt"
    lb "go-study/mylib"
)

func init() {
    fmt.Println("hi main")
}

func main() {
    var a, b int32 = 1, 2
    fmt.Println(lb.Add(a, b))
}

12. Go的反射

12.1. Go反射类型

通过reflect包来进行反射，可以获得类型

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import (
    "fmt"
    "reflect"
)

func main() {
    a := 1
    ta := reflect.TypeOf(a)
    fmt.Println(ta.Bits(), ta.Name(), ta.Kind())
}

对于name和kind的区别，看看下面这份代码就行了, name为Point，kind为struct

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
    "fmt"
    "reflect"
)

type Point struct {
    X, Y int32
}

func main() {
    var a = Point{}
    ta := reflect.TypeOf(a)
    fmt.Println(ta.Name(), ta.Kind())
}

12.2. Go反射值

通过字段的名字获取属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
    "fmt"
    "reflect"
)

type Point struct {
    X, Y int32
}

func main() {
    var a = Point{}
    ta := reflect.ValueOf(a)
    fmt.Println(ta.FieldByName("X"))
}


13. Go的并发

13.1. goroutine

在关键词go后跟着一个函数调用，那么该函数调用就变成了goroutine，这是一个异步调用，立即返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
    "fmt"
    "time"
)

func running() {
    times := 1
    for {
        fmt.Println("tick", times)
        times++
        time.Sleep(time.Second)
    }
}

func main() {
    go running()
    for {
        time.Sleep(time.Second)
    }
}

13.2. Go的通道

下面的程序会依次输出0和hello， 通道先进先出 <-符号可以用来传输数据， 注意通道在发送和接受的时候都会阻塞,注意到最后一行有一个time.Sleep(time.Second)，这是为了等待goroutine完成，否则main退出以后goroutine会直接强制退出

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
package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan interface{})

    go func() {
        ch <- 0
        fmt.Println("send: 0")
        ch <- "hello"
        fmt.Println("send: hello")
    }()

    time.Sleep(time.Second)

    data := <-ch
    fmt.Println("recv: ", data)

    time.Sleep(time.Second)

    data = <-ch
    fmt.Println("recv: ", data)

    time.Sleep(time.Second)
}

另一种接受方法是使用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
package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan interface{})

    go func() {
        ch <- 0
        fmt.Println("send: 0")
        ch <- "hello"
        fmt.Println("send: hello")
        ch <- "break"
        fmt.Println("send: break")
    }()

    for data := range ch {
        fmt.Println("recv:", data)
        if data == "break" {
            break
        }
    }

    time.Sleep(time.Second)
}


最后通道还支持指定输入端和输出端，输入端只能做输入，输出端只能做输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan interface{})

    var send chan<- interface{} = ch
    var recv <-chan interface{} = ch

    go func() {
        send <- 0
    }()

    data := <-recv
    fmt.Println("recv:", data)

    time.Sleep(time.Second)
}

创建带有缓冲区的通道, 只需要在make的第二个参数中填入数字即可

1
ch := make(chan interface{}, 10)

多路复用，使用select关键字，case区域写要选择的通道即可接收多个通道，下面的代码有时输出1，有时输出2

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
package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan interface{})
    ch2 := make(chan interface{})

    go func() {
        ch1 <- 1
    }()

    go func() {
        ch2 <- 2
    }()

    time.Sleep(time.Second)

    select {
    case data := <-ch1:
        fmt.Println("recv from ch1: ", data)
    case data := <-ch2:
        fmt.Println("recv from ch2: ", data)
    }

    time.Sleep(time.Second)
}