Go语言之函数详解

函数：
使用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。