golang入门

October 31, 2022

Playground
https://golang.google.cn/play/
Go 指南
https://tour.go-zh.org/
Go by example
https://gobyexample-cn.github.io/
Go 语言圣经（中文版）
https://gopl-zh.github.io/
Mastering GO
https://github.com/hantmac/Mastering_Go_ZH_CN
https://books.studygolang.com/Mastering_Go_ZH_CN/
Golang for Node.js Developers
https://github.com/miguelmota/golang-for-nodejs-developers
参考
https://books.studygolang.com/
https://github.com/jaywcjlove/golang-tutorial
https://github.com/iswbm/GolangCodingTime
https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/directory.md
https://github.com/polaris1119/The-Golang-Standard-Library-by-Example/blob/master/directory.md
标准库
https://pkg.go.dev/std
https://studygolang.com/pkgdoc

分号是可选的！

包，导入导出

包实现了命名空间的管理
任何一个 Go 语言程序必须属于一个包，即每个 go 程序的开头要写上 package <pkg_name>

package main

import (
    "fmt"
    "math/rand"
)
// 或者
// import "fmt"
// import "math/rand"

func main() {
    fmt.Println("My favorite number is", rand.Intn(10))
}

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。
比如函数 rand.Intn 和变量 math.Pi

// 以别名导入
package main

import (
    f "fmt"
)

func main() {
    f.Println("f")
}

// 将包的命名空间合并到当前程序的命名空间
package main

import . "fmt"

func main() {
    Println("f")
}

函数

func add(x int, y int) int {
    return x + y
}

// 连续几个参数类型相同，可以省略前面的类型
func add(x, y int) int {
    return x + y
}


// 可以返回多个值
func swap(x, y string) (string, string) {
    return y, x
}

func main() {
    a, b := swap("hello", "world")
    fmt.Println(a, b)
}

// 返回值可以被命名，这些命名可以出现在文档中，
// 最后的 return 不用带参数就可以把命名的返回值全部返回
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

函数的类型就是函数声明去除函数名、函数参数名、函数体剩下的部分
当然，此时需标注所有参数的类型

func(int, int) int

函数也是值
所以闭包也是支持的

add := func(x, y int) int {
    return x + y
}

func addFn(x, y int, fn func(int, int) int) int {
    return fn(x, y)
}
addFn(1, 2, add)

变量

基本类型

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
rune // int32 的别名，表示一个 Unicode 码点
float32 float64
complex64 complex128

零值

没有明确初始值的变量声明会被赋予它们的零值。

数值类型为 0
布尔类型为 false
字符串为 ""

// var 声明一组变量列表
var num, i, count int
var a, b, c = true, 123, "no!";

// const 声明常量
const Pi = 3.14
const (
    Big = 1 << 100
    Small = Big >> 99
)

// `:=` 简洁赋值语句，仅可在函数内使用
func main() {
    var i, j int = 1, 2
    k := 3
}

类型转换

不同的类型之间不会进行隐式转换
显式转换，只需像这样转换到的类型(被转换的变量)：

var i = 42
var f = float64(i)

控制结构

for

只有 for，但包含多种功能

func main() {
    sum := 0
    for i := 0; i < 10; i++ {
        sum += i
    }
}

func main() {
    sum := 1
    for sum < 1000 {
        sum += sum
    }
}

// 无限循环
for {
    // code goes here
}

if

if 语句可以在条件表达式前执行一个简单的语句，该语句声明的变量作用域仅在 if 之内

if x:= rand.Intn(10); x > 5 {
    fmt.Println("BIG!")
} else {
    fmt.Println("Small!")
}

switch

switch 无需 break，作为替代，在有需要时可以使用 fallthrough
此外 case 的值无需为常量（比如可以为一个函数返回值）
没有条件的 switch 同 switch true 一样

func main() {
    fmt.Print("Go runs on ")
    switch os := runtime.GOOS; os {
    case "darwin":
        fmt.Println("OS X.")
    case "linux":
        fmt.Println("Linux.")
    default:
        // freebsd, openbsd,
        // plan9, windows...
        fmt.Printf("%s.\n", os)
    }
}

defer

defer 语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。
推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

func main() {
    defer fmt.Println("world")
    fmt.Println("hello")
}
// hello
// world

指针与结构体

指针类型*T表示指向T类型的指针
&操作符可创建变量的指针，指针的零值为nil
*操作符可访问指针指向的值

var i int = 1
var p *int = &i
fmt.Println(i)  // 1
fmt.Println(*p) // 1
*p = 2
fmt.Println(i) // 2

type Vertex struct {
    X int
    Y int
}

func main() {
    v := Vertex{1, 2} // 相当于 Vertex{X: 1, Y: 2}
    p := &v
    p.X = 1e9  // 相当于 (*p).X
    fmt.Println(v)
}

数组与切片

类型 [n]T 表示拥有 n 个 T 类型的值的数组
数组的切片是对数组的引用，切片的零值则是nil
切片下界的默认值为 0，上界则是该切片的长度

func main() {
    var a [2]string
    a[0] = "Hello"
    a[1] = "World"
    fmt.Println(a[0], a[1])
    fmt.Println(a)

    primes := [6]int{2, 3, 5, 7, 11, 13}
    fmt.Println(primes)

    var s []int = primes[1:4] // 切片，左闭右开！注意，切片的类型相当于对应数组类型但方括号中为空
    fmt.Println(s)

    primess := []int{2, 3, 5, 7, 11, 13} // 方括号中没有指明数组容量，则我们得到的是切片而不是数组！
}

切片具有长度(len)和容量(cap)

a := make([]int, 5)  // len(a)=5
b := make([]int, 0, 5) // len(b)=0, cap(b)=5

b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:]      // len(b)=4, cap(b)=4

func append(s []T, vs ...T) []T
// append 函数创建了一个在原切片上追加元素的新切片

// range循环同时返回切片的下标和对应元素的*副本*
for i, v := range []int{1, 2, 3} {
    fmt.Printf("index=%d value=%d\n", i, v)
}

映射 (map)

映射的类型是 map[K]V K 是键的类型，V 是值的类型
若指定键不在映射中，那么其对应值是该映射元素类型的零值

m := make(map[string]Vertex)
m["hello"] = Vertex{3, 6}
fmt.Println(m["hello"]) // {3 6}
fmt.Println(m["world"]) // {0 0} 零值

// or
var m = map[string]Vertex{
    "hello": Vertex{3, 6},
    "world": Vertex{4, 8},
}
// or
var m = map[string]Vertex{
    "hello": {3, 6},
    "world": {4, 8},
}

delete(m, "key")
elem := m["key"]
elem, ok := m["key"]

方法和接口

方法

方法只是个带接收者参数的函数

type Vertex struct {
    X, Y float64
}

// 方法
func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    v := Vertex{3, 4}
    fmt.Println(v.Abs())
}

// 相当于普通函数
func Abs(v Vertex) float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    v := Vertex{3, 4}
    fmt.Println(Abs(v))
}

接收者的类型定义和方法声明必须在同一包内
不能为内建类型声明方法（但可以通过给其它（内建）类型起别名来规避）

在需要修改接收者指向的值时，可以为指针接收者声明方法

func (v *Vertex) Scale(f float64) {
    v.X = v.X * f
    v.Y = v.Y * f
}

与普通函数不同的是：以指针为接收者的方法被调用时，接收者既能为值又能为指针
因为此时 Go 会将值解释为指针：v.Scale(5) -> (&v).Scale(5) 从而能对值进行修改以值为接收者的方法被调用时，接收者既能为值又能为指针，p.Abs() 会被解释为 (*p).Abs()

接口

类型通过实现一个接口的所有方法来实现该接口

type I interface {
    M()
}

type T struct {
    S string
}

func (t *T) M() {
    if t == nil {
        fmt.Println("<nil>")
        return
    }
    fmt.Println(t.S)
}

type F float64

func (f F) M() {
    fmt.Println(f)
}

func main() {
    var i I

    i = &T{"Hello"}
    describe(i) // (&{Hello}, *main.T)
    i.M()       // Hello

    i = F(math.Pi)
    describe(i) // (3.141592653589793, main.F)
    i.M()       // 3.141592653589793

    var t *T
    i = t
    describe(i) // (<nil>, *main.T)
    i.M() // <nil>

    i = nil
    describe(i) // (<nil>, <nil>)
    i.M() // panic: runtime error: invalid memory address or nil pointer dereference
}

func describe(i I) {
    fmt.Printf("(%v, %T)\n", i, i)
}

空接口 interface{} 可以保存任意类型的值
类型断言t := i.(T)则可以访问接口底层的具体值
类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值

func main() {
    var i interface{} = "hello"

    s := i.(string)
    fmt.Println(s)

    s, ok := i.(string)
    fmt.Println(s, ok)

    f, ok := i.(float64)
    fmt.Println(f, ok) // 0 false

    f = i.(float64) // panic: interface conversion: interface {} is string, not float64
    fmt.Println(f)
}

通过类型选择可以按顺序从几个类型断言中进行选择
与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值）

func do(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Twice %v is %v\n", v, v*2)
    case string:
        fmt.Printf("%q is %v bytes long\n", v, len(v))
    default:
        // 没有匹配，v 与 i 的类型相同（这里是 interface{}）
        fmt.Printf("I don't know about type %T!\n", v)
    }
}

错误处理

Go 程序使用 error 值来表示错误状态
接口 error 是内建接口

type error interface {
    Error() string
}

通过检查返回的 error 接口值是否为 nil 得知是否发生错误

type MyError string

func (e MyError) Error() string {
    return string(e)
}

func divide(a, b int) (n int, err error) {
    if b == 0 {
        return 0, MyError("除数不能为零")
    }
    return a / b, nil
}

func main() {
    result, err := divide(2, 0)
    if err == nil { // 无错误
        fmt.Println(result)
    } else { // 有错误
        fmt.Println(err)
    }
}

并发

Go 程（goroutine）是由 Go 运行时管理的轻量级线程。

go f(x, y, z)启动一个 go 程

go 程通过信道（channel）通信，信道是带有类型的管道

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 将和送入 c
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从 c 中接收

    fmt.Println(x, y, x+y)
}

信道可以是带缓冲的。将缓冲长度作为第二个参数提供给 make 来初始化一个带缓冲的信道
仅当信道的缓冲区填满后，向其发送数据时才会阻塞。当缓冲区为空时，接受方会阻塞。

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

发送者可通过 close 关闭一个信道（向一个已经关闭的信道发送数据会引发 panic）
接收者可以通过为接收表达式分配第二个参数来测试信道是否被关闭 v, ok := <-ch

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    for i := range c {
        fmt.Println(i)
    }
}

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
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }() // 这是一个立即执行表达式，且在go程中执行
    fibonacci(c, quit)
}

当 select 中的其它分支都没有准备好时，default 分支就会执行。（不阻塞）

func main() {
    tick := time.Tick(100 * time.Millisecond)
    boom := time.After(500 * time.Millisecond)
    for {
        select {
        case <-tick:
            fmt.Println("tick.")
        case <-boom:
            fmt.Println("BOOM!")
            return
        default:
            fmt.Println("    .")
            time.Sleep(50 * time.Millisecond)
        }
    }
}

sync.Mutex 互斥锁类型，支持互斥操作

import "sync"

type SafeCounter struct {
    v   map[string]int
    mux sync.Mutex
}

func (c *SafeCounter) Inc(key string) {
    c.mux.Lock()
    c.v[key]++ // 临界区
    c.mux.Unlock()
}

func (c *SafeCounter) Value(key string) int {
    c.mux.Lock()
    defer c.mux.Unlock() // 注意defer的用法
    return c.v[key] // 临界区
}

←Back to home