一、函数基础
- 函数由函数声明关键字 func、函数名、参数列表、返回列表、函数体组成
- 函数是一种类型。函数类型变量可以像其他类型变量一样使用，可以作为其他函数的参数或返回值，也可以直接调用执行
- 函数名首字母大小写决定了其包可见性
- 参数和返回值需用
()包裹，如果返回值是一个非命名的参数，则可省略。函数体使用{}包裹，且{必须位于同行行尾
1. 基本使用
// 1. 可以没有输入参数，也可以没有返回值（默认返回 0）
func A() {
...
}
// 2. 多个相邻的相同类型参数可以使用简写模式
func B(a, b int) int {
return a + b
}
// 3. 支持有名的返回值
func C(a, b int) (sum int) {
// sum 相当于函数体内的局部变量，初始化为零值
sum = a + b
return // 可以不带 sum
}
// 4. 不支持默认值参数
// 5. 不支持函数重载
// 6. 不支持函数嵌套定义，但支持嵌套匿名函数
func D(a, b int) (sum int) {
E := func(x, y int) int {
return x + y
}
return E(a, b)
}
// 7. 支持多值返回（一般将错误类型作为最后一个返回值）
func F(a, b int) (int, int) {
return b, a
}
// 8. 函数实参到形参的传递永远是**值拷贝**
func G(a *int) { // a 是实参指针变量的副本，和实参指向同一个地址
*a += 1
}
2. 不定参数
// 1. 不定参数类型相同
// 2. 不定参数必须是函数的最后一个参数
// 3. 不定参数在函数体内相当于切片
func sum(arr ...int) (sum int) {
for _, v := range arr { // arr 相当于切片，可使用 range访问
sum += v
}
return
}
// 4. 可以将切片传递给不定参数
array := [...]int{1, 2, 3, 4} // 不能将数组传递给不定参数
slice := []int{1, 2, 3, 4}
sum(slice...) // 切片名后要加 ...
// 5. 形参为不定参数的函数和形参为切片的函数类型不同
func suma(arr ...int) (sum int) {
for v := range arr {
sum += v
}
return
}
func sumb(arr []int) (sum int) {
for v := range arr {
sum += v
}
return
}
fmt.Printf("%T
", suma) // func(...int) int
fmt.Printf("%T", sumb) // func([]int) int
3. 函数类型
函数类型又叫函数签名：函数定义行去掉函数名、参数名和 {
func add(a, b int) int { return a + b }
func sub(x int, y int) (c int) { c = x - y; return }
fmt.Printf("%T", add) // func(int, int) int
fmt.Printf("%T", sub) // func(int, int) int
可以使用 type 定义函数类型。函数类型变量和函数名都可以看做指针变量，该指针指向函数代码的开始位置
func add(a, b int) int { return a + b }
func sub(a, b int) int { return a - b }
type Op func(int, int) int // 定义一个函数类型：输入两个 int，返回一个 int
func do(f Op, a, b int) int {
t := f
return t(a, b)
}
fmt.Println(do(add, 1, 2)) // 3
fmt.Println(do(sub, 1, 2)) // -1
4. 匿名函数
// 1. 直接赋值给函数变量
var sum = func(a, b int) int {
return a + b
}
func do(f func(int, int) int, a, b int) int {
return f(a, b)
}
// 2. 作为返回值
func getAdd() func(int, int) int {
return func(a, b int) int {
return a + b
}
}
func main() {
// 3. 直接被调用
defer func() {
if err:= recover(); err != nil {
fmt.Println(err)
}
}()
sum(1, 2)
getAdd()(1 , 2)
// 4. 作为实参
do(func(x, y int) int { return x + y }, 1, 2)
}
二、函数高级
1. defer
可注册多个延迟调用函数，以先进后出的顺序执行。常用于保证资源最终得到回收释放
func main() {
// defer 后跟函数或方法调用，不能是语句
defer func() {
println("first")
}()
defer func() {
println("second")
}()
println("main")
}
// main
// second
// first
defer 函数的实参在注册时传递，后续变更无影响
func f() int {
a := 1
defer func(i int) {
println("defer i =", i)
}(a)
a++
return a
}
print(f())
// defer i = 1
// 2
defer 若位于 return 后，则不会执行
func main() {
println("main")
return
defer func() {
println("first")
}()
}
// main
若主动调用os.Exit(int)退出进程，则不会执行 defer
func main() {
defer func() {
println("first")
}()
println("main")
os.Exit(1)
}
// main
关闭资源例子
func CopyFile(dst, src string) (w int64, err error) {
srcFile, err := os.Open(src)
if err != nil {
return
}
// defer 一般放在错误检查语句后面。若位置不当可能造成 panic
defer srcFile.Close()
dstFile, err := os.Create(dst)
if err != nil {
return
}
defer dstFile.Close()
w, err = io.Copy(dstFile, srcFile)
return
}
defer 使用注意事项：
- defer 会延迟资源的释放
- 尽量不要放在循环语句中
- defer 相对于普通函数调用需要间接的数据结构支持，有一定性能损耗
- defer 中最好不要对有名返回值进行操作
2. 闭包
- 闭包是由函数及其相关引用环境组合成的实体。一般通过在匿名函数中引用外部函数的局部变量或包全局变量构成
- 闭包对闭包外的环境引入是直接引用：编译器检测到闭包，会将闭包引用的外部变量分配到堆上
- 闭包是为了减少全局变量，在函数调用的过程中隐式地传递共享变量。但不够清晰，一般不建议用
- 对象是附有行为的数据，而闭包是附有数据的行为。类在定义时已经显式地集中定义了行为，但闭包中的数据没有显式地集中声明的地方
// fa 返回的是一个闭包：形参a + 匿名函数
func fa(a int) func(i int) int {
return func(i int) int {
println(&a, a)
a = a + i
return a
}
}
func main() {
f := fa(1) // f 使用的 a 是 0xc0000200f0
g := fa(1) // g 使用的 a 是 0xc0000200f8
// f、g 引用的闭包环境中的 a 是函数调用产生的副本：每次调用都会为局部变量分配内存
println(f(1))
println(f(1)) // 闭包共享外部引用，因此修改的是同一个副本
println(g(1))
println(g(1))
}
// 0xc0000200f0 1
// 2
// 0xc0000200f0 2
// 3
// 0xc0000200f8 1
// 2
// 0xc0000200f8 2
// 3
闭包引用全局变量（不推荐）
var a = 0
// fa 返回的是一个闭包：全局变量a + 匿名函数
func fa() func(i int) int {
return func(i int) int {
println(&a, a)
a = a + i
return a
}
}
func main() {
f := fa()
g := fa()
// f、g 引用的闭包环境中的 a 是同一个
println(f(1))
println(g(1))
println(f(1))
println(g(1))
}
// 0x511020 0
// 1
// 0x511020 1
// 2
// 0x511020 2
// 3
// 0x511020 3
// 4
同一个函数返回的多个闭包共享该函数的局部变量
func fa(a int) (func(int) int, func(int) int) {
println(&a, a)
add := func(i int) int {
a += i
println(&a, a)
return a
}
sub := func(i int) int {
a -= i
println(&a, a)
return a
}
return add, sub
}
func main() {
f, g := fa(0) // f、g 使用的 a 都是 0xc0000200f0
s, k := fa(0) // s、k 使用的 a 都是 0xc0000200f8
println(f(1), g(2))
println(s(1), k(2))
}
// 0xc0000200f0 0
// 0xc0000200f8 0
// 0xc0000200f0 1
// 0xc0000200f0 -1
// 1 -1
// 0xc0000200f8 1
// 0xc0000200f8 -1
// 1 -1
三、错误处理
1. 错误和异常
- 广义的错误：发生非期望的行为
- 狭义的错误：发生非期望的己知行为
- 这里的己知是指错误类型是预料并定义好的
- 异常：发生非期待的未知行为，又被称为未捕获的错误
- 这里的未知是指错误的类型不在预先定义的范围内
- 程序在执行时发生未预先定义的错误，程序编译器和运行时都没有及时将其捕获处理，而是由操作系统进行异常处理。如 C 语言的 Segmentation Fault
Go 不会出现 untrapped error，只需处理 runtime errors 和程序逻辑错误
Go 提供两种错误处理机制
- 通过 panic 打印程序调用栈，终止程序来处理错误
- 通过函数返回错误类型的值来处理错误
Go 是静态强类型语言，程序的大部分错误是可以在编译器检测到的，但有些错误行为需要在运行期才能检测出来，此种错误行为将导致程序异常退出。建议：
- 若程序发生的错误导致程序不能继续执行，此时程序应该主动调用 panic
- 若程序发生的错误能够容错继续执行，此时应该使用 error 返回值的方式处理，或在非关键分支上使用 recover 捕获 panic
2. panic 和 recover
panic(i interface{}) // 主动抛出错误
recover() interface{} // 捕获抛出的错误
- 引发panic情况：①主动调用panic；②程序运行时检测抛出运行时错误
- panic 后，程序会从当前位置返回，逐层向上执行 defer 语句，逐层打印函数调用栈，直到被 recover 捕获或运行到最外层函数退出
- 参数为空接口类型，可以传递任意类型变量
- defer 中也可以 panic，能被后续 defer 捕获
- recover 只有在 defer 函数体内被调用才能捕获 panic，否则返回 nil
// 以下场景捕获失败
defer recover()
defer fmt.Println(recover())
defer func() {
func() { // 两层嵌套
println("defer inner")
recover()
}()
}()
// 以下场景捕获成功
defer func() {
println("defer inner")
recover()
}()
func except() {
recover()
}
func test() {
defer except()
painc("test panic")
}
可以同时有多个 panic（只会出现在 defer 里），但只有最后一次 panic 能被捕获
func main() {
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
}
fmt.Println(recover())
}()
defer func() {
panic("first defer panic")
}()
defer func() {
panic("second defer panic")
}()
panic("main panic")
}
// first defer panic
// <nil>
包中 init 函数引发的 panic 只能在 init 函数中捕获（init 先于 main 执行）
函数不能捕获内部新启动的 goroutine 抛出的 panic
func do() {
// 不能捕获 da 中的 panic
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
}
}()
go da()
time.Sleep(3 * time.Second)
}
func da() {
panic("panic da")
}
3. error
Go 内置错误接口类型 error。任何类型只要实现Error() string方法，都可以传递 error 接口类型变量？？？
type error interface {
Error() string
}
使用 error：
- 在多个返回值的函数中，error 作为函数最后一个返回值
- 若函数返回 error 类型变量，先处理
error != nil的异常场景，再处理其他流程 - defer 放在 error 判断的后面
四、底层实现
TODO