1.定义

函数是结构化编程的最小单元模式。它将复杂的算法过程分解为若干个较小任务,隐藏相关细节,使程序结构更加清晰,易于维护。
函数被设计成相对独立,通过接收输入参数完成一段算法指令,输出或存储相关结果。

一个函数的声明通常包括关键字func、函数名、分别由圆括号包裹的列表参数和结果列表
以及由花括号包裹的函数体,就像这样:

func divide(dividend int,divisor int)(int,error){
//函数体
}

函数可以没有参数列表,也可以没有结果列表,但空参数列表必须保留括号,而结果列表则不用,示例如下:

func divide(){
//函数体
}

另外,参数列表中的必须有名称,而结果列表中结果的名称则可有可无。
不过,结果列表中的结果要么都省略名称,要么都要有名称。
带有结果名称的divide函数的声明如下:

func divide(dividend int,divisor int)(result int,err error){
//函数体
}

如果函数的结果有名称,那么在函数被调用时,以它们为名的变量就会被隐式声明。
如此一来在函数中就可以直接使用它们了,就像使用参数那样。
给代表结果的变量赋值,就相当于设置函数的返回结果。

在Go中,函数类型是一等类型,这意味着可以把函数当作一个值来传递和使用。
函数值既可以作为其它函数地参数,也可以作为其结果。另外,我们还可以利用函数类型的这一特性来生成闭包。

package main

import "fmt"

func hello() {
fmt.Println("hello, world")
} func exec(f func()) { //将函数作为参数
f()
} func main() {
f := hello
exec(f)
} /*
结果:
hello, world
*/

  

函数只能判断其是否为nil,不支持其它比较操作。

package main

import "fmt"

func a() {}
func b() {} func main() {
fmt.Println(a == nil) //false
fmt.Println(a == b) //不支持比较操作
//invalid operation: a == b (func can only be compared to nil)
//无效操作:a == b (函数只能去判断其是否为nil)
}

  

从函数返回局部变量指针是安全的,编译器会通过逃逸分析来决定是否在堆上分配内存。

package main

import "fmt"

func test() *int { //*int  返回值时指针类型
a := 0x100
return &a
} func main() {
var a *int = test() //定义一个指针类型的变量
fmt.Println(a, *a) //a指针变量 *a反向取值
} /*
结果:
0xc00000a168 256
*/

  

2.参数

Go对参数的处理偏向保守,不支持有默认值的可选参数,不支持命名实参。
调用时,必须按签名顺序传递指定类型和数量的实参,就算是“_”命名的参数也不能忽略。

package main

import "fmt"

func test(x, y int, s string, _ bool) *int {
return nil
} func main() {
test(1, 2, "abc") // not enough arguments in call to test定义了四个变量却只传递了三个
}

  

在Go中应该避免在相同层次定义同名变量。

package main

import "fmt"

func add(x, y int) int {  //形参和实参冲突
x := 100 //no new variables on left side of :=
var y int
return x + y
} func main() {
result := add(10, 20)
fmt.Println(result)
}

  

在函数中定义的参数,我们称之为形参,函数被调用时所传递的参数我们称之为实参。
形参类似于函数的局部变量,而实参则是函数的外部对象,可以是常量、变量、表达式或函数。

package main

import "fmt"

func test(x *int) {
fmt.Println(&x, x)
} func main() {
a := 0x100
p := &a
fmt.Println(&p, p)
test(p)
} /*
结果:
0xc000076018 0xc00004e080
0xc000076028 0xc00004e080
*/

  

虽然形参和实参都指向一个目标,但是传递指针时依然被复制的。

不管传递的参数是指针、引用类型,还是其它类型参数,默认采用的都是值拷贝传递。
值拷贝传递就是在调用函数时将实际参数复制一份传递到函数中,
这样在函数中如果对参数进行修改,将不会影响到实际参数。

package main

import "fmt"

func main() {
var a int = 100
var b int = 200 fmt.Printf("交换前a的值为%d\n", a)
fmt.Printf("交换前b的值为%d\n", b) swap(a, b) fmt.Printf("交换前a的值为%d\n", a)
fmt.Printf("交换前b的值为%d\n", b) } func swap(x, y int) int {
var temp int temp = x
x = y
y = temp return temp
} /*
交换前a的值为100
交换前b的值为200
交换前a的值为100
交换前b的值为200
*/

另外一种是引用传递,就是在调用函数时将实际参数的地址传递到函数中,那么在函数中,对参数所进行的修改。

package main

import "fmt"

func main() {
var a int = 100
var b int = 200 fmt.Printf("交换前a的值为%d\n", a)
fmt.Printf("交换前b的值为%d\n", b) swap(&a, &b) //交换的是指针 fmt.Printf("交换前a的值为%d\n", a)
fmt.Printf("交换前b的值为%d\n", b) } func swap(x *int, y *int) int {
var temp int temp = *x
*x = *y
*y = temp return temp
}
/*
交换前a的值为100
交换前b的值为200
交换前a的值为200
交换前b的值为100
*/

  

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

package main

import (
"fmt"
"log"
"time"
) type serverOption struct { //定义结构体
address string
port int
path string
timeout time.Duration
log *log.Logger
} func newOption() *serverOption { //以函数的形式返回默认参数
return &serverOption{
address: "0.0.0.0",
port: 8080,
path: "/var/test",
timeout: time.Second * 5,
log: nil,
}
} func server(option *serverOption) { //需要操作的函数
fmt.Println(option)
} func main() {
opt := newOption()
opt.port = 8085 //修改属性值
server(opt)
} /*
结果:
&{0.0.0.0 8085 /var/test 5000000000 <nil>}
*/

  

在Go中还有一种称之为变参的用法,就是一个标识符传递多个参数的用法。
变参本质上就是一个切片。只能接收一到多个同类型的参数,且必须放在列表尾部。
将切片作为变参时,需进行展开操作。如果是数组,先将其转换为切片。

package main

import "fmt"

func test(s string, a ...int) {
fmt.Println(s, a)
} func main() {
test("abc", 1, 2, 3, 4, 5) x := []int{10, 20, 30} //使用切片作为变参
test("abc", x...) y := [3]int{40, 50, 60} //使用数组作为变参
test("abc", y[:]...) }
/*
结果:
abc [1 2 3 4 5]
abc [10 20 30]
abc [40 50 60]
*/

  

3.返回值

有返回值的函数,必须有明确的return终止语句。

package main

func test(a int) int { //函数如果有返回值就必须定义返回值的类型
if a > 0 {
return 1
} else if a < 0 {
return 2 //missing return at end of function
}
//逻辑必须完整,这里缺少一个else
} func main() {
test(5)
}

  

函数体中每个条件分支的最后一般都要有return语句,该语句以return关键字开始,
后跟与函数结果列表相匹配的变量、常量、表达式或值。
无论是什么,它们都会被求值并得到确切的值。
但是,如果函数声明的结果是有名称的,那么return关键字后面就不用追加任何东西了。

package main

import (
"errors"
"fmt"
) func div(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("division by zero")
}
return x / y, nil
} func main() {
fmt.Println(div(10, 3))
}

  

在Go中没有元组类型可以用来接收返回值,也不能使用数组或者切片就收,但是可以用“_”忽略掉不想要的返回值。
多返回值可用作其它函数调用实参,或当作结果直接返回。

package main

import (
"errors"
"fmt"
) func div(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("division by zero")
}
return x / y, nil
} func log(x int, err error) {
fmt.Println(x, err)
} func test() (int, error) {
return div(5, 0) //多返回值用作return结果
} func main() {
log(test()) //多返回值用作实参
}

  

还有一种对返回值常用的操作是在定义函数的时候给返回值命名。
返回值和参数一样,可以当作函数局部变量使用,最后由return隐式返回。

package main

import "fmt"

func div(x, y int) (z int, err error) {
if y == 0 {
err = errors.New("division by zero")
return //这样就可以直接进行return
}
z := x / y, nil
return
} func main() {
fmt.Println(div(10, 3))
}

  

需要注意的是,这些特殊的“局部变量”会被不同层级的同名变量遮蔽,这时候就需要使用显式地return返回。

package main

import "fmt"

func add(x, y int) (z int) {
{
z := x + y //新定义的同名局部变量,同名遮蔽
return //z is shadowed during return,改成return z就可以
}
return
} func main() {
fmt.Println(add(10, 1))
}

  

此外,我们在命名地时候要全部命名,除非返回值能明确表明其含义,就可以省略命名。

package main

func test() (int, s string) { //cannot use 1 (type int) as type string in return argument
//要么都命名,要么都不命名
return 1, "abc"
} func main() {
test()
}

  

4.匿名函数

匿名函数是指没有定义名字符号地函数。
除没有名字外,匿名函数和普通函数完全相同。
最大的区别是,我们可在函数内部定义匿名函数,形成类似嵌套效果。
匿名函数常见的使用方法有四种:直接使用、保存到变量、作为参数和返回值。

(1)直接执行

package main

import "fmt"

func main() {
func(s string) {
fmt.Println(s)
}("科比要结婚了") //直接执行
}

  

(2)复制给变量

package main

import "fmt"

func main() {
add := func(x, y int) int { //赋值给变量
return x + y
}
fmt.Println(add(1, 3)) //4
}

  

(3)作为参数

package main

import "fmt"

func test(f func()) {
f()
} func main() {
test(func() { //匿名函数作为参数
fmt.Println("都走吧")
})
}

  

(4)作为返回值

package main

import "fmt"

func test() func(int, int) int {  //func(int, int) int:func(int, int)这是返回值名称,后面的int是返回值的类型
return func(x, y int) int { //直接返回一个函数
return x + y
}
} func main() {
add := test() //得到一个函数
fmt.Println(add(11, 22)) 传参
}

相比与语句块来说,匿名函数的作用域是被隔离的,不会引发外部污染,更加灵活。

5.闭包

在python中,你调用了一个函数A,但是函数A直接给你返回一个B函数,那么B函数就是闭包函数,
在B函数中,调用函数A的变量称作自由变量。
其实在Go语言中,闭包也是类似的定义。

package main

import "fmt"

func test(s string) func() {
return func() {
fmt.Println(s)
}
} func main() {
reslut := test("时光悠悠")
reslut()
}  

test返回的匿名函数会引用上下文环境变量s。
当该函数在main中执行时,它依然可以正确的读取x的值,这种现象就被称作闭包。
还有一种闭包的说法就是,如果在一个内部函数里,对在外部作用域(但不是全局作用域)的变量进行引用,
那么内部函数就被认为是闭包。
那么闭包是如何实现的了?匿名函数被返回之后,为何还能读取环境的变量值了?

package main

import "fmt"

func test(s string) func() {
fmt.Println(&s, s) return func() {
fmt.Println(&s, s)
}
} func main() {
reslut := test("时光悠悠")
reslut()
} /*
0xc0000421c0 时光悠悠
0xc0000421c0 时光悠悠
*/

  

通过指针我们发现闭包直接引用了原环境变量。
正是因为闭包通过指针引用环境变量,那么可能会导致其生命周期延长。
但这有时候会带来一些问题。

package main

import "fmt"

func test() []func() {
var s []func() //定义一个数组 for i := 0; i < 2; i++ {
s = append(s, func() { //添加元素
fmt.Println(&i, i)
})
}
return s //返回匿名函数列表
} func main() {
for _, f := range test() { //迭代执行所有匿名函数
f()
}
} /*
0xc00000a168 2
0xc00000a168 2
*/

  

这并不是我们想要看到的结果,为什么了?
for循环复用局部变量i,那么每次添加的匿名函数引用的就是同一个变量。
添加元素的操作仅仅是将匿名函数放入列表而并没有执行,所以就会出现这种状况。
解决办法就是每次使用不同的环境变量或传参复制,让各自闭包环境各不相同。

package main

import "fmt"

func test() []func() {
var s []func() //定义一个数组 for i := 0; i < 2; i++ {
x := i
s = append(s, func() { //添加元素
fmt.Println(&x, x)
})
}
return s
} func main() {
for _, f := range test() {
f()
}
} /*
结果:
0xc00000a168 0
0xc00000a180 1
*/

  

多个匿名函数引用同一变量时,任何修改都会影响其它函数的取值,这是我们需要注意的。

package main

import "fmt"

func test(x int) (func(), func()) { //返回两个匿名函数
return func() {
fmt.Println(x)
x += 10 //修改环境变量
}, func() {
fmt.Println(x)
}
} func main() {
a, b := test(100)
a() //100
b() //110
}

所以对于闭包应该慎用。

6.延迟调用

除了前面介绍的流程控制语句外,Go还有一些特有的流程控制语句,其中一个就是defer。
该语句用于延迟调用指定的函数,它只能出现在函数内部,由defer关键字以及针对某个函数的调用表达式组成。
这里被调用的函数称为延迟函数。

func outerFunc() {
defer fmt.Println("函数执行结束前一刻才会被打印") //延迟执行,调用fmt.PrintLn
fmt.Println("第一个被打印") //延迟函数
}

其中,defer关键字后面是针对fmt.Println函数的调用表达式。代码里面也说明了延迟函数的执行时机。
这里的outerFunc称为外围函数,调用outerFunc的那个函数称为调用函数。
下面是具体的规则:
  a.当外围函数中的语句正常执行完毕时,只有其中所有的延迟函数都执行完毕,外围函数才会真正结束执行。
  b.当执行外围函数中的return语句时,只有其中所有的延迟函数都执行完毕后,外围函数才会真正返回。
  c.当外围函数中的代码引发运行异常,只有其中所有的延迟函数都执行完毕后,该运行异常才会被真正扩散至调用函数。
正因为defer语句有这样的特性,所以它成为了执行释放资源或异常处理等收尾任务的首选。
明显的优势有以下两个:
  A.对延迟函数的调用总会在外围函数执行结束前执行。
  B.defer语句在外围函数体中的位置不限,并且数量不限。

不过,使用defer语句还有三点需要注意:
第一点,如果在延迟函数中使用外部变量,就应该通过参数传入。

func printNumbers() {
for i := 0; i < 5; i++ {
defer func() {
fmt.Printf("%d", i)
}()
}
}

上述代码的执行结果是55555,这正是由于延迟函数的执行实际引起的,for循环执行完毕之后,才会执行延迟函数。
也就是说,当执行延迟函数的时候,i已经等于5了。

func printNumbers() {
for i := 0; i < 5; i++ {
defer func(n,int) {
fmt.Printf("%d", n)
}(i)
}
}

打印的内容会是43210,至于为什么,请看下面的第二点。

第二点:同一个外围函数内多个延迟函数调用的执行顺序,会与其所属的defer语句的执行顺序完全相反。
同一个外围函数中的每个defer语句执行的时候,针对其延迟函数的调用表达式都会被压入同一个栈。
在该外围函数执行结束的那一刻,Go会从这个栈中依次取出,栈的取值顺序是先进后出。

第三点:延迟函数调用,若有参数传入,那么那些参数的值会在当前defer语句执行时求出。

func printNumbers() {
for i := 0; i < 5; i++ {
defer func(n,int) {
fmt.Printf("%d", n)
}(i*2)
}
}

此时,执行的结果是86420

最后看一个例子:

package main

import (
"fmt"
) func main() {
x, y := 1, 3 defer func(a int) {
fmt.Println("defer x, y=", a, y) //y为闭包引用
}(x) //注册时复制调用参数,所以x为1 x += 100
y += 200
fmt.Println(x, y)
} /*
101 203
defer x, y= 1 203
*/

  

7.错误处理

(1)error

标准库将error定义为接口类型,以便发现自定义错误类型。

type error interface {
Error() string
}

按惯例,error总是最后一个返回参数。标准库提供了相关创建函数,
可以很方便的创建包含简单错误处理文本的error对象。

package main

import (
"errors"
"fmt"
"log"
) var errDivByZero = errors.New("division by zero") func div(x, y int) (int, error) {
if y == 0 {
return 0, errDivByZero
}
return x / y, nil
} func main() {
z, err := div(5, 0)
if err == errDivByZero {
log.Fatalln(err)
} fmt.Println(z)
} /*
2018/11/30 03:15:24 division by zero
exit status 1
*/

  

某些时候,我们需要自定义错误类型,以便容纳更多的上下文状态信息。

package main

import (
"fmt"
"log"
) type DivError struct {
x, y int
} func (DivError) Error() string {
return "division by zero"
} func div(x, y, int) (int, error) {
if y == 0 {
return 0, DivError{x, y}
}
return x / y, nil
} 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)
}

  

(2)panic和recover

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

package main

import (
"fmt"
"log"
) func main() {
defer func() {
if err := recover(); err != nil {
log.Fatalln(err)
}
}() panic("I dead")
fmt.Println("exit!")
} /*
2018/11/30 03:35:18 I dead
exit status 1
*/

  

因为panic参数是空接口类型,因此可以使用任何对象作为错误状态。
无论是否执行recover,所有延迟都会被执行。
但中断性错误会调用堆栈向外传递,要么被外层捕获,要么导致进程崩溃。t/css" />

从函数返回局部变量指针是安全的,编译器会通过逃逸分析来决定是否在堆上分配内存。

package main

import (
"fmt"
"log"
) func test() {
defer fmt.Println("test.1")
defer fmt.Println("test.2") panic("I dead")
} func main() {
defer func() {
log.Fatalln(recover())
}() test()
} /*
test.2
test.1
2018/11/30 03:39:02 I dead
exit status 1
*/

连续调用panic,仅最后一个会被recover捕获。

go——函数的更多相关文章

  1. Python 小而美的函数

    python提供了一些有趣且实用的函数,如any all zip,这些函数能够大幅简化我们得代码,可以更优雅的处理可迭代的对象,同时使用的时候也得注意一些情况   any any(iterable) ...

  2. 探究javascript对象和数组的异同,及函数变量缓存技巧

    javascript中最经典也最受非议的一句话就是:javascript中一切皆是对象.这篇重点要提到的,就是任何jser都不陌生的Object和Array. 有段时间曾经很诧异,到底两种数据类型用来 ...

  3. JavaScript权威指南 - 函数

    函数本身就是一段JavaScript代码,定义一次但可能被调用任意次.如果函数挂载在一个对象上,作为对象的一个属性,通常这种函数被称作对象的方法.用于初始化一个新创建的对象的函数被称作构造函数. 相对 ...

  4. C++对C的函数拓展

    一,内联函数 1.内联函数的概念 C++中的const常量可以用来代替宏常数的定义,例如:用const int a = 10来替换# define a 10.那么C++中是否有什么解决方案来替代宏代码 ...

  5. 菜鸟Python学习笔记第一天:关于一些函数库的使用

    2017年1月3日 星期二 大一学习一门新的计算机语言真的很难,有时候连函数拼写出错查错都能查半天,没办法,谁让我英语太渣. 关于计算机语言的学习我想还是从C语言学习开始为好,Python有很多语言的 ...

  6. javascript中的this与函数讲解

    前言 javascript中没有块级作用域(es6以前),javascript中作用域分为函数作用域和全局作用域.并且,大家可以认为全局作用域其实就是Window函数的函数作用域,我们编写的js代码, ...

  7. 复杂的 Hash 函数组合有意义吗?

    很久以前看到一篇文章,讲某个大网站储存用户口令时,会经过十分复杂的处理.怎么个复杂记不得了,大概就是先 Hash,结果加上一些特殊字符再 Hash,结果再加上些字符.再倒序.再怎么怎么的.再 Hash ...

  8. JS核心系列:浅谈函数的作用域

    一.作用域(scope) 所谓作用域就是:变量在声明它们的函数体以及这个函数体嵌套的任意函数体内都是有定义的. function scope(){ var foo = "global&quo ...

  9. C++中的时间函数

    C++获取时间函数众多,何时该用什么函数,拿到的是什么时间?该怎么用?很多人都会混淆. 本文是本人经历了几款游戏客户端和服务器开发后,对游戏中时间获取的一点总结. 最早学习游戏客户端时,为了获取最精确 ...

  10. Python高手之路【四】python函数装饰器

    def outer(func): def inner(): print('hello') print('hello') print('hello') r = func() print('end') p ...

随机推荐

  1. 01 Servlet & Jsp 技术概述

    Servlet 介绍 servlet 是运行在web服务器或应用服务器上的java程序, 它是一个中间层, 负责连接来自web浏览器或其他http客户端的请求和HTTP服务器上的数据库或应用程序. 为 ...

  2. Android开发 获取当前activity的屏幕截图(转载)

    首先通过下面的函数获取Bitmap格式的屏幕截图: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 pu ...

  3. 第二百三十三节,Bootstrap表格和按钮

    Bootstrap表格和按钮 学习要点: 1.表格 2.按钮 本节课我们主要学习一下 Bootstrap 表格和按钮功能,通过内置的 CSS 定义,显示各 种丰富的效果. 一.表格 Bootstrap ...

  4. 一站式WPF--依赖属性(DependencyProperty)二

    书接上文,前篇文章介绍了依赖属性的原理和实现了一个简单的DependencyProperty(DP),这篇文章主要探讨一下如何使用DP以及有哪些需要注意的地方. 回顾 依赖属性是由Dependency ...

  5. Windows应用程序运行权限设置

    在Vista以后的windows版本中,有些时候需要提升编译后生成程序的权限,即希望让生成的程序以管理员身份运行.虽然在一般情况下,可以使用鼠标右键选择的方式来强行以管理员身份运行,但它并没有屏蔽普通 ...

  6. Python程序的性能分析指南(转)

    原文地址 :http://blog.jobbole.com/47619/ 虽然不是所有的Python程序都需要严格的性能分析,不过知道如何利用Python生态圈里的工具来分析性能,也是不错的. 分析一 ...

  7. Android开发:《Gradle Recipes for Android》阅读笔记(翻译)5.4——使用Espresso测试Activity

    问题: 你想要使用Google的Espresso测试Activity. 解决方案: 在Gradle配置里面增加Espresso,书写测试脚本. 讨论: Espresso测试库已经被添加进“Androi ...

  8. poj3414

    Pots Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 13545   Accepted: 5717   Special J ...

  9. [Algorithms] Longest Increasing Subsequence

    The Longest Increasing Subsequence (LIS) problem requires us to find a subsequence t of a given sequ ...

  10. 【文章阅读】详解MySQL数据类型

    详解MySQL数据类型 - 五月的仓颉 - 博客园 http://www.cnblogs.com/xrq730/p/8446246.html 注:对于MySQL的数据类型做了详细的讲解,这是我看过的最 ...