1. 跳出/执行下一次循环。

{标签名}:
for true {
   ...
   for true {
       ...
       break/continue {标签名}  //默认不加标签，则跳出最近一层循环。加了标签可以跳出标签定义处所在循环
   }
}

2. map的使用注意项。

因为map是指针，作为参数传递时，在函数内部对map作的修改直接修改外部传递变量的值。

3. slice(切片)使用注意点。

与map一样，都可以用make创建，但slice返回的是结构体。当slice作为参数传递时，在函数内部修改可能会影响slice

4. 遍历循环for range和排序sort的使用。

package main

import (
	"fmt"
	"sort"
)

func main() {
	sl := []int{219, 373, 543, 351, 523, 625, 436, 252, 121, 567, 896, 454, 342, 734, 464, 423, 164}
	min, max := getMinAndMax(sl)
	fmt.Println("sl中最小值:", min)
	fmt.Println("sl中最大值:", max)
	sort.Ints(sl) //根据类型进行正向排序
	fmt.Println("切片排序获取sl中最小值:", sl[0])
	fmt.Println("切片排序获取sl中最大值_1:", sl[len(sl)-1:][0])
	sort.Sort(sort.Reverse(sort.IntSlice(sl))) //反射排序
	fmt.Println("切片排序获取sl中最大值_2:", sl[0])
}

func getMinAndMax(arr []int) (min int, max int) {
	if len(arr) == 0 {
		return 
	}
	min, max = arr[0], arr[0]
	for _, v := range arr {
		if v > max {
			max = v
		} else if v < min {
			min = v
		}
	}
	return
}

上面代码执行结果:

sl中最小值: 121
sl中最大值: 896
切片排序获取sl中最小值: 121
切片排序获取sl中最大值_1: 896
切片排序获取sl中最大值_2: 896

5. defer用法。

defer是函数退出前必须执行逻辑，类似栈，后进先出，最后执行要先写

package main

import (
	"fmt"
)

func main() {
	fmt.Println("start...")
	for i := 0; i < 3; i++ {
		defer fmt.Println(i)
	}
	fmt.Println("end")
}

上面代码执行结果:

start...
end
2  
1  
0  

defer函数实参是值拷贝进去,所以i++不影响defer中的值。
注意：return之后的defer不会执行；调用os.Exit(1)的函数不执行defer。

package main

import (
	"fmt"
)
//return后写defer
func main() {
	fmt.Println("start...")
	return
	defer fmt.Println("defer逻辑")
	fmt.Println("end")
}
//函数中使用了os.Exit(1)
func main() {
	fmt.Println("start...")
	defer fmt.Println("defer逻辑")
	fmt.Println("end")
	os.Exit(1)
}

6. 匿名函数用法。

package main

import (
	"fmt"
	"time"
)

var FunB = func() {
	fmt.Println("全局匿名函数")
}

func main() {
	fmt.Println("start...")
	go func() {
		fmt.Println("匿名函数")
	}()
	a := func() {
		fmt.Println("给变量赋值的匿名函数")
	}
	go a()
	go FunB()
	time.Sleep(1 * time.Second)
	fmt.Println("end")
}

7. defer + recover捕获panic，不会让一个panic使整个app程序奔溃的简单方法，提高程序的健壮性。

package main

import "fmt"

func main() {
	testPanic()
	fmt.Println("test_end")
}

func testPanic() {
	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("panic被捕获")
		}
	}()
	a := 10
	b := 0
	fmt.Println("a/b=", a/b)
}

8. 自定义错误。

errors.New("自定义错误内容")

9. 自定义函数进行多函数单一操作。

package main

import "fmt"

func add(a, b int) int {
	return a + b
}
func sub(a, b int) int {
	return a - b
}
func nul(a, b int) int {
	return a * b
}

type Op func(int, int) int

func do(f Op, a, b int) int {
	return f(a, b)
}

func main() {
	c, d := 102087, 65421
	e := do(add, c, d)
	fmt.Println("c+d=", e)
	f := do(sub, c, d)
	fmt.Println("c-d=", f)
	g := do(nul, c, d)
	fmt.Println("c*d=", g)
}

10. 接口的使用说明。

接口是一种抽象类型，接口实现时要注意值与指针接收者的问题。
在go语言中，一个类型(主要是struct)可以实现多个不同的接口，接口之间互不影响；也可以多个类型实现同一个接口，即间接实现面向对象的开发方式。go里面的接口不需要类型(对象)完全实现所有函数方法，接口可以通过在类型中嵌入其它类型来实现。还可以通过接口不断嵌套创造出新的接口。
注意：go语言中有空接口概念(interface{})，即没有定义任何函数方法的接口，因此任何类型都实现了空接口，空接口类型的变量也就可以接收任意类型的变量(类似其它面向对象语言中的Object对象)，用途非常广但需要断言正确，否则实现出现未知错误。

11. goroutine 并发使用。

并发是指同一时间段内执行的多个任务。并行是指同一时刻执行多个任务。goroutine是go语言中并发的实现，它类似于线程，但是属于用户态的线程，由go语言运行时调度完成，不同于线程由操作系统调度完成。

 ...
	go func(){
	   //并发执行函数逻辑
	}()
 ...

常用sync.Wait.WaitGroup来解决多个并发中安全问题

12. 多个并发goroutine之前的通信channel应用。

chan类型也和map、slice(切片)类型一样，用make创建。

-end-