Go语言之函数详解

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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。


以上是关于Go语言之函数详解的主要内容,如果未能解决你的问题,请参考以下文章

Go语言之数据类型详解

[Golang]函数详解

Go语言ioutil包详解

go语言:函数参数传递详解

go语言:函数参数传递详解

go语言:函数参数传递详解