2020-08-03发表2022-04-21更新Golang10 分钟读完 (大约1480个字)0次访问

Golang：半个月从入门到辞退?

这不是标题党，这是一份学习笔记，记录遇到的问题，包括但不仅仅限于 golang 的语法格式、常用用法、神奇操作等。

Update: 本以为一篇长文就可以搞定这个入门到辞退，感觉东西好多啊，还是分开多篇吧。

关键字

func

编译报错，返回值要么都有名，要么都没有名称。

1
2
3

func funcMui(x, y int) (sum int, error) {
	return x + y, nil
}

range

func main() {
	slice := []int{0, 1, 2, 3}
	m := make(map[int]*int)

	for key, val := range slice {
		m[key] = &val
	}

	for k, v := range m {
		fmt.Println(k, "->", *v)
	}
}

输出：

[Running] go run "/tmp/main.go"
0 -> 3
1 -> 3
2 -> 3
3 -> 3

defer

是用来延迟执行某个操作，可以是语句、也可以是函数，而且延迟发生在调用函数 return 之后。
defer 的重要用途

清理释放资源

执行 recover

被 defer 的函数在 return 之后执行，这个时机点正好可以捕获函数抛出的 panic，因而 defer 的另一个重要用途就是执行 recover。recover 只有在 defer 中使用才更有意义，如果在其他地方使用，由于 program 已经调用结束而提前返回而无法有效捕捉错误。

package main

import "fmt"
func main() {
    defer func() {
        if ok := recover(); ok != nil {
            fmt.Println("recover")
        }
    }()
    panic("error")
}

多个 defer 后进先出

将 defer 视为一个入栈操作，内容是函数或语句，如果有 defer 语句，但是没有执行到，也就没有入栈，最终也不会执行。

func test() {
	defer func() { fmt.Println("2") }()
	defer func() { fmt.Println("3") }()
	defer func() { fmt.Println("4") }()

	panic("触发异常")
}

func main() {
	defer func() { fmt.Println("1") }()
	test()
}

运行结果为：
多个defer

被 deferred 函数的参数在 defer 时确定

func a() {
    i := 0
    defer fmt.Println(i)
    i++
    return
}
// 输出 0
func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}
func main() {
    a := 1
    b := 2
    defer calc("1", a, calc("10", a, b))
    a = 0
    return
}
// 输出 
// 10, 1, 2, 3
// 1, 1, 3, 4

被 defer 的函数可以读取和修改带名称的返回值

func c() (i int) {
    defer func() { i++ }()
    return 1
}

返回2

new

内建函数，函数原型为

1	func new(Type) *Type

官方文档描述为：

The new build-in function allocates memory（仅仅分配空间）. The first argument is a type, not a value, and the value returned is a pointer to a newly allocated zero value of that type.

内置函数 new 分配空间。传递给new 函数的是一个类型，不是一个值。返回值是指向这个新分配的零值的指针。

根据这段描述，我们也可以自己实现一个类似 new 的功能

func newInt *int {
	var i int
	return &i   //为何可以返回局部变量呢？
}
someInt := newInt()

这里要注意的第一点是，返回值是一个指针。

为何一个golang 中的函数可以返回局部变量呢？

golang 和 c 语言不一样，栈区分配的存储空间不会随着函数的返回而释放，本地变量地址所占据的存储空间会生存下来。那么什么时候会释放呢？什么情况下才会释放呢？

make

内建函数，函数原型是：

1	func make(Type, size IntegerType) Type

第一个参数是一个类型，第二个参数是长度，返回值是一个类型

make 仅用于创建 Slice, Map 和 Channel

The make built-in function allocates and initializes an object（分配空间 + 初始化） of type slice, map or chan**(only)**. Like new , the first arguement is a type, not a value. Unlike new, make’s return type is the same as the type of its argument, not a pointer to it. The specification of the result depends on the type.

Slice:
The size specifies the length. The capacity of the slice is equal to its length. A second integer argument may be provided to specify a different capacity; it must be no smaller than the length. For example, make([]int, 0, 10) allocates an underlying array of size 10 and returns a slice of length 0 and capacity 10 that is backed by this underlying array.

Map:
An empty map is allocated with enough space to hold the specified number of elements. The size may be omitted, in which case a small starting size is allocated.

Channel:
The channel’s buffer is initialized with the specified buffer capacity. If zero, or the size is omitted, the channel is unbuffered.

内建函数 make 分配并且初始化一个 slice, 或者 map 或者 chan 对象。并且只能是这三种对象。和 new 一样，第一个参数是类型，不是一个值。但是make 的返回值就是这个类型（即使一个引用类型），而不是指针。具体的返回值，依赖具体传入的类型。

Slice : 第二个参数 size 指定了它的长度，此时它的容量和长度相同。
你可以传入第三个参数来指定不同的容量值，但是必须不能比长度值小。
比如: make([]int, 0, 10)
Map: 根据size 大小来初始化分配内存，不过分配后的 map 长度为0。如果 size 被忽略了，那么会在初始化分配内存的时候分配一个小尺寸的内存。
Channel: 管道缓冲区依据缓冲区容量被初始化。如果容量为 0 或者被忽略，管道是没有缓冲区的。

1 2	var p *[]int = new([]int) var v []int = make([]int, 10)

上述第一条语句使用 new() 函数为切片结构分配内存，*p == nil （这意味着什么？意味着没有对Slice结构进行初始化），但是在实际中这种用法很少使用。
第二条语句使用 make() 函数创建了一个有10个元素的 Slice对象。

// [0 0 0 0 0 1 2 3]
func main1() {
	s := make([]int, 5)
	s = append(s, 1, 2, 3)
	fmt.Println(s)
}
// [1 2 3 4]
func main2() {
	s := make([]int, 0)
	s = append(s, 1, 2, 3, 4)
	fmt.Println(s)
}

协程

协程间通信

如何让主协程等待子协程特定的时间，比如说 3s，超时后忽略子协程。