Go语言之函数详解

Posted 2020-10-18

函数：

使用func定义函数。

1.不用前置声明

2.不支持命名嵌套定义

3.不支持同名函数重载

4.不支持默认参数

5.支持不定长变参

6.支持多返回值

7.支持命名返回值

8.支持匿名函数和闭包

函数是第一类对象，具备相同签名的看作是同一类型。第一类对象是指可在运行期间创建，可作为函数参数或者是返回值，可存入变量的实体。最常见的用法就是匿名函数。

从函数返回局部变量的指针是安全的，编译器会通过逃逸分析(escape analysis)来决定是否在堆上分配内存。函数内联是对内存分配有一定影响的。

函数命名建议的命名规则：

1.通常是动词和介词加上名词

2.避免不必要的缩写

3.避免使用类型关键字

4.避免歧义，不能有多种用途的解释造成误解

5.避免只能通过大小写区分同名函数

6.避免与内置函数同名，这会导致误用

7.避免使用数字，除非是特定专有名词

8.同一使用驼峰命名法

9.使用相同术语，保持一致性

10.使用习惯用语

11.使用反义词命名组合行为相反的函数

函数和方法的命名方式稍有不同，方法通过选择符调用，并且具备状态上下文，可使用更加简短的方式进行。

参数：在参数列表中，相邻的同类型参数合并，参数可以视作函数的局部变量，因此不能再相同层次定义同名变量。不管是指针、引用类型、还是其他类型参数都是值的拷贝传递。

表面上，指针参数的性能要更好一些，但是实际上具体分析，被复制的指针会延长目标对象的生命周期，还可能会导致他被分配到堆上去，那么其性能消耗就得加上堆内存分配和垃圾回收的成本。

其实在栈上复制小对象，只需要很少的指令就会完成，远比运行时进行的堆内存分配要快。并发编程也尽量提倡尽可能使用不可变的对象(只读或者是复制)，这可能消除数据同步等麻烦。

如果复制成本较高，或者是需要修改原来对象的状态，自然使用指针比较好。

要实现传出参数，通常建议使用返回值，也可以使用二级指针。

如果函数参数过多，建议将其重构为一个复合结构体类型。

将过多的参数独立成为结构体，便于扩展参数集，也方便通过新的函数设置默认配置。这也是一段代码复用的方式，避免多处调用时繁琐的参数配置。

变参：

变参的本质就是切片，只能接受一个到多个同一类型的参数，并且必须放在列表尾部。

将切片作为变参，必须进行展开操作。如果是数组，先将其转换为切片。

参数复制仅仅是切片本身，并不比包括底层数组，可以使用内置函数copy进行复制底层数据。

package main

import (

"fmt"

)

func main() {

a := [3]int{10,20,30}

test(a[:]...)    //转换为slice后进行展开

}

func test (a ...int){

fmt.Println(a)

}

有返回值的函数必须明确的写入return语句。

除非有panic或者是break的死循环，就不需要return语句。

多返回值模式，函数就会返回更多的状态，尤其是error模式。

可以使用“_”忽略不想要的返回值。

命名返回值：对返回值命名和简短的变量定义一样。

package main

import (

"fmt"

)

func main() {

x,y,z := test("tom","city",12)

fmt.Println(x,y,z)//12 tom city

}

func test(name,address string ,index int) (x int ,y,z string){

x  = index

y,z  = name,address

return

}

命名返回值和参数一样，可以当做函数局部变量使用，最后由return语句进行隐式返回。

编译器在处理return语句的时候会跳过未命名的返回值，无法准确匹配。

匿名函数：匿名函数可以直接调用，保存到变量，作为参数或者是返回值。

package main

import "fmt"

func main() {

func (s string){

fmt.Println(s)//Hello

}("Hello")

}

编译器会为匿名函数生一个随机的符号名。未曾使用的匿名函数会被编译器当做错误。

除去闭包因素以外，匿名函数也是一种常见的重构手段。可以将大函数分解为多个相对独立的匿名函数块。

相比语句块，匿名函数的作用域被隔离(不使用闭包)，不会引发外部污染。

闭包：是指在其词法上下文中引用了自由变量的函数。

package main

import "fmt"

func main() {

f := test(10)

f()

}

func test(x int)func(){

return func(){

fmt.Println(x)//10

}

}

延迟调用：

defer语句向当前函数注册稍后执行的函数调用。这些调用被叫做延迟调用，当前函数执行完毕以后才会执行，常用于资源释放、解除锁定、以及错误处理等模块。

延迟调用注册的是调用，必须提供执行所需要的参数。参数值在注册的时候会被复制并缓存起来，如果对状态比较敏感，可以改为指针或者是闭包。多个延迟是按照FILO的顺序进行执行的。

在性能要求高并且压力大的算法中，应该避免使用延迟调用。

错误处理：官方推荐的做法是返回error状态。按照惯例，error总是最后一个返回的对象。某些时候可以自定义错误类型，以容纳更多的上下文状态信息，这样可以基于类型做出判断。

package main

import (

"fmt"

"log"

)

func main() {

z,err := div(5,0)

if err != nil{

switch e := err.(type) {//匹配类型

case divError:

fmt.Println(e, e.x, e.y)

default:

fmt.Println(e)

}

log.Fatalln(err)

}

fmt.Println(z)

}

//自定义错误类型

type divError struct {

x,y int

}

//实现error接口方法

func (divError) Error() string{

return "divsion is 0"

}

//返回自定义错误类型

func div(x,y int) (int,error){

if y == 0{

return 0,divError{x,y}

}

return  x / y,nil

}

当存在很多代码检查语句的时候的解决方法：

1.使用专门的检查函数处理错误逻辑，简化检查代码。

2.在不影响逻辑的情况下，使用defer延后处理错误日志，是err赋值退化。

3.在不中断逻辑的情况下，将错误作为内部状态保存，等最终提交结果的时候进行处理。

painc，recover：

painc会立即中断当前的函数流程，执行延迟调用。而在延迟调用函数中，recover可以捕获并返回panic提交的错误对象。

因为panic参数是空接口类型，因此可以使用任何对象作为错误状态。而recover返回结果同样要做转型才能获得具体信息。

无论是否执行recover，所有的延迟调用都会被执行。但是中断性错误会眼调用堆栈向外传递，不是被外层捕获就是会导致进程崩溃。

package main

import "log"

func main() {

defer func(){

log.Println(recover())

}()

test()

}

func test(){

defer println("test:1")

defer println("test:2")

panic("dead:1")

}

联系调用panic，只最后一个会被recover捕获。

package main

import (

"log"

)

func main() {

defer func(){

if err := recover();err != nil {

log.Println(err)

}else{

log.Fatalln("fatal")

}

}()

defer func(){

panic("dead")

}()

panic("dead2")

}

由于recover的特性，如果要保护代码片段，只能将其重构为函数进行调用。

除非是不可恢复的、导致系统无法正常工作的错误，否则不建议使用panic。