函数
函数定义
定义方式如下:
func funcName([parameter list])[returnTypes]{
//func body
}
其中返回值类型和参数都是可选的
go语言不支持默认值参数
不支持函数重载
不支持命名函数的嵌套定义,但支持嵌套匿名函数
举例:
func getSum(num1 int,num2 int) int{
return num1 + num2
}
//也可以定义为如下格式,参数相同类型省略掉前边的,编译器自动推断
func GetSum1(num1, num2 int) int {
result := num1 + num2
return result
}
值传递与引用传递
- 值传递是指在函数调用过程中将实参拷贝一份到函数中,这样在函数中如果对参数进行修改,将不会影响到实参。
- 引用传递是指在函数调用过程中将实参的地址传递到函数中,那么在函数中对参数所进行的修改,将影响到实参。
Go函数实参到形参永远是值拷贝,所以实现引用传递可以通过传递指针变量的方式
func paramFunc(a int, b *int, c []int) {
//指针传递,将变量地址传入
a = 100
*b = 100
c[1] = 100
fmt.Println("paramFunc:")
fmt.Println(a)
fmt.Println(*b)
fmt.Println(c)
}
func main() {
a := 1
b := 1
c := []int{
1, 2, 3}
paramFunc(a, &b, c)
fmt.Println("main:")
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
}
/*输出
paramFunc:
100
100
[1 100 3]
main:
1
100
[1 100 3]
*/
变长参数
go语言中支持变长参数。
注意:
- 所有的不定参数类型必须是相同的
- 不定参数必须是函数的最后一个参数
- 不定参数名在函数体内相当于切片,对切片的操作同样适合对不定参数的操作
- 切片作为参数传递给不定参数,切片名后要加上“…”
- 形参为不定参数的函数和形参为切片的函数类型不相同
- 数组不可以作为实参传递给不定参数的函数
func main() {
slice := []int{
7, 9, 3, 5, 1}
x := min(slice...)
fmt.Printf("The minimum is: %d", x)
}
func min(s ...int) int {
if len(s) == 0 {
return 0
}
min := s[0]
for _, v := range s {
if v < min {
min = v
}
}
return min
}
多返回值
Go 函数支持多值返回,定义多值返回的返回参数列表时要使用“()”包裹,支持命名参数
的返回。
func swap(a,b int) (int,int){
return b,a
}
若返回结果与一个错误值,这样可以使函数的调用者很方便的知道函数是否执行成功,这样的模式也被称为command,ok模式,未来的程序设计中也推荐使用这种方式。
func div(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("The divisor cannot be zero.")
}
return a / b, nil
}
func main() {
result, err := div(1, 2)
if err != nil {
fmt.Printf("error: %v", err)
return
}
fmt.Println("result: ", result)
}
命名返回值
在go语言中还可以给返回值命名,当需要返回的时候,只需要一条简单的不带参数的return语句
func div(a, b float64) (result float64, err error) {
if b == 0 {
return 0, errors.New("被除数不能等于0")
}
result = a / b
return
}
即使只有一个命名返回值,也需要使用()
括起来
匿名函数
匿名函数如其名字一样,是一个没有名字的函数,除了没有名字外其他地方与正常函数相同。匿名函数可以直接调用,保存到变量,作为参数或者返回值。
package main
import "fmt"
//匿名函数被直接赋值函数交量
var sum= func(a , b int) int {
return a + b
}
func doinput(f func(int , int) int , a , b int) int {
return f(a , b)
}
//匿名函数作为返回值
func wrap(op string) func(int, int) int {
switch op {
case "add":
return func(a, b int) int {
return a + b
}
case "sub":
return func(a , b int) int {
return a + b
}
default:
return nil
}
}
func main() {
//匿名函数直接被调用
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
}
}()
sum(1, 2)
//匿名函数作为实参
out := doinput(func(x, y int) int {
return x + y
}, 1, 2)
opFunc := wrap("add")
re := opFunc(2, 3)
fmt.Println(out) //3
fmt.Println(sum(1, 2)) //3
fmt.Printf("%d\n", re) //5
}
闭包
闭包可以解释为一个函数与这个函数外部变量的一个封装。粗略的可以理解为一个类,类里面有变量和方法,其中闭包所包含的外部变量对应着类中的静态变量。 为什么这么理解,先看一个例子:
func add() func(int) int {
n := 10
str := "string"
return func(x int) int {
n = n + x
str += strconv.Itoa(x)
fmt.Print(str, " ")
return n
}
}
func main() {
f := add()
fmt.Println(f(1))
fmt.Println(f(2))
fmt.Println(f(3))
f = add()
fmt.Println(f(1))
fmt.Println(f(2))
fmt.Println(f(3))
}
/*输出
string1 11
string12 13
string123 16
string1 11
string12 13
string123 16
*/
解释:
- 最开始先声明一个函数
add
,在函数体内返回一个匿名函数 - 其中的
n
,str
与下面的匿名函数构成了整个的闭包,n
与str
就像类中的静态变量只会初始化一次,所以说尽管后面多次调用这个整体函数,里面都不会再重新初始化了 - 而且对于外部变量的操作是累加的,这与类中的静态变量也是一致的
闭包实现斐波那契数列:
package main
import "fmt"
func fib() func() int {
a,b := 0,1
return func() int{
tmp := a
a,b = b,(a+b)
return tmp
}
}
func main(){
f := fib()
for i:=0 ; i<10; i++ {
fmt.Println(f())
}
}