Go语言基础之函数

函数

Go语言中支持函数、匿名函数和闭包,并且函数在Go语言中属于“一等公民”。是非常重要的

函数定义

Go语言中定义函数使用func关键字,具体格式如下:

func 函数名(参数)(返回值){
    函数体
}

其中:

  • 函数名:由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内,函数名也称不能重名(包的概念详见后文)。
  • 参数:参数由参数变量和参数变量的类型组成,多个参数之间使用,分隔。
  • 返回值:返回值由返回值变量和其变量类型组成,也可以只写返回值的类型,多个返回值必须用()包裹,并用,分隔。
  • 函数体:实现指定功能的代码块。

我们先来定义一个简单函数

func intSum(x int, y int) int {
	return x + y
}

函数的参数和返回值都是可选的,例如我们可以实现一个既不需要参数也没有返回值的函数:

func sayHello() {
	fmt.Println("Hello 沙河")
}

还可以指定返回多少个字段和指定类型

func addSub(x int, y int) (sum int, sub int) {
	sum = x + y
	sub = x - y
	return sum, sub
}

函数的调用

定义了函数之后,我们可以通过函数名()的方式调用函数。
例如:

func processFuncHello() {
	a,b := addSub(1,2)
	fmt.Println(a,b)
}

注意,调用有返回值的函数时,可以不接收其返回值。

参数

类型简写

函数的参数中如果相邻变量的类型相同,则可以省略类型,例如:

func intSum(x, y int) int {
	return x + y
}

上面的代码中,intSum函数有两个参数,这两个参数的类型均为int,因此可以省略x的类型,因为y后面有类型说明,x参数也是该类型。

可变参数

可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加...来标识。

注意:可变参数通常要作为函数的最后一个参数。

格式:

func processFuncDemo6(x int,v...int)  {
	
}

func 函数名 (固定参数列表,v...T)(返回参数列表){

}

v...T实际是切片 记得这一点

举个例子:

func processFuncDemo6(x int, v ...int) {
	//v是切片
	fmt.Println(v)
	sum := x
	for _, v := range v {
		sum += v
	}
	fmt.Println(sum)
}

调用上面的函数:

processFuncDemo6(10, 1, 2, 3)
processFuncDemo6(10, 1, 2, 3, 4)

输出:

[1 2 3]
16
[1 2 3 4]
20

可变参数的传递

可变参数本质上是一个切片,如果要在多个函数中传递可变参数 可在传递时添加 ...

代码如下:

func add(num ...int) {
	addAll(num...)
}
func addAll(slice ...int) {
	sum := 0
	for _, value := range slice {
		sum += value
	}
	fmt.Println(sum)
}
func main() {
	add(1, 2, 3, 4, 5)
}

如果想传递可变参数的本身,可将addAll函数的可变参数改成切片

func add(num ...int) {
	addAll(num)
}
func addAll(slice [] int) {
	sum := 0
	for _, value := range slice {
		sum += value
	}
	fmt.Println(sum)
}

多返回值

Go语言中函数支持多返回值,函数如果有多个返回值时必须用()将所有返回值包裹起来(单返回值是不需要括号包裹起来的)

举个例子:

func calc(x, y int) (int, int) {
	sum := x + y
	sub := x - y
	return sum, sub
}

返回值命名

函数定义时可以给返回值命名,并在函数体中直接使用这些变量,最后通过return关键字返回。

func main() {
	sum, sub := calc(1, 2)
	fmt.Println(sum, sub)
}
func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}

函数变量

go语言中,函数也是一种类型,我们可以将其保存在变量中

函数变量声明格式:

var 变量名称 func()

如以下代码:

func addSub(x int, y int) (sum int, sub int) {
	sum = x + y
	sub = x - y
	return sum, sub
}
// 变量函数
func processFuncDemo4() {
	a := 1
	b := 2
	//定义了函数变量
	var f1 func(x int, y int) (sum int, sub int)
	//将addSub函数绑定到f1变量
	f1 = addSub
	fmt.Printf("type of f1:%T\n", f1)
	sum, sub := f1(a, b)
	fmt.Println(a, "+", b, "=", sum)
	fmt.Println(a, "-", b, "=", sub)
}

输出

type of f1:func(int, int) (int, int)
1 + 2 = 3
1 - 2 = -1

 函数变量f1声明后 其值初始化为nil,在将addSub函数赋值给f1后,所有对f1的调用即为对addSub函数的调用

函数变量也是可以用短变量声明和初始化的

代码:

// 短变量函数
func processFuncDemo5() {
	a := 1
	b := 2
	//使用短格式声明
	f1 := addSub
	fmt.Printf("type of f1:%T\n", f1)
	sum, sub := f1(a, b)
	fmt.Println(a, "+", b, "=", sum)
	fmt.Println(a, "-", b, "=", sub)
}

输出

type of f1:func(int, int) (int, int)
1 + 2 = 3
1 - 2 = -1

其实还有另外一种方式

定义函数类型

我们可以使用type关键字来定义一个函数类型,具体格式如下:

type calculation func(int, int) int

上面语句定义了一个calculation类型,它是一种函数类型,这种函数接收两个int类型的参数并且返回一个int类型的返回值。

简单来说,凡是满足这个条件的函数都是calculation类型的函数,例如下面的processAdd和processSub是calculation类型。

func processAdd(x, y int) int {
	return x + y
}

func processSub(x, y int) int {
	return x - y
}

调用代码:

type calculation func(int, int) int
func processFuncDemo7() {
	// 声明一个calculation类型的变量c
	var c calculation
	c = processAdd
	fmt.Printf("type of c:%T\n", c)
	// 像调用processAdd一样调用c
	fmt.Println(c(1, 2))

	//与其有区别的另外一种写法
	f := processAdd
	fmt.Printf("type of f:%T\n", f)
	fmt.Println(f(1, 2))
}
func main() {
	processFuncDemo7()
}

输出:

type of c:main.calculation
3
type of f:func(int, int) int
3

从输出可以看出区别了

c变量是calculation类型的变量
而f是对processAdd 函数直接的调用

高阶函数

高阶函数分为函数作为参数和函数作为返回值两部分。

函数作为参数

函数可以作为参数:

func processFuncCalc(x, y int, op func(int, int) int) int {
	//op是一个参数
	return op(x, y)
}
func processFuncDemo8() {
	//processAdd是传递的参数
	ret2 := processFuncCalc(10, 20, processAdd)
	fmt.Println(ret2)
}

函数作为返回值

函数也可以作为返回值:

func processFuncDemo9() {
	sum, err := do("+")
	if sum == nil {
		fmt.Println(err)
	} else {
		fmt.Println(sum(1, 2), err)
	}

}
func do(s string) (func(int, int) int, error) {
	switch s {
	case "+":
		return processAdd, nil
	case "-":
		return processSub, nil
	default:
		err := errors.New("无法识别的操作符")
		return nil, err
	}
}

匿名函数和闭包

匿名函数

函数还可以作为返回值,但是在Go语言中函数内部不能再像之前那样定义函数了,只能定义匿名函数。匿名函数就是没有函数名的函数,匿名函数的定义格式如下:

func(参数)(返回值){
    函数体
}

匿名函数因为没有函数名,所以没办法像普通函数那样调用,所以匿名函数需要保存到某个变量或者作为立即执行函数:

在匿名函数后"()"直接传入实参

func processFuncDemo10() {
	// 将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20)
	//自执行函数:匿名函数定义完加()直接执行
	//(里面是参数值)
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 21)
}

匿名函数多用于实现回调函数和闭包。

看以下代码

func main() {
	processFuncDemo13()
}
func processFuncDemo12(i int) func() int {
	return func() int {
		i++
		return i
	}
}
func processFuncDemo13() {
	a1 := processFuncDemo12(5)
	fmt.Println(a1())
	fmt.Println(a1())
	a2 := processFuncDemo12(10)
	fmt.Println(a2())
	fmt.Print("a1闭包的地址为:")
	fmt.Printf("%p\n", &a1)
	fmt.Print("a2闭包的地址为:")
	fmt.Printf("%p\n", &a2)
}

输出:

6
7
11
a1闭包的地址为:0xc0000ca020
a2闭包的地址为:0xc0000ca030

详解

processFuncDemo12函数返回了一个闭包函数,通过定义a1和a2变量,创建了两个闭包的实例(引用环境不同导致)

每次调用闭包实例,i的值都会在原有的基础上加1  从打印的结果可以看到 两个闭包实例的地址完全不同,两个闭包的调用结果互不影响

闭包进阶示例

func processMakeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}
func processFuncDemo14() {
	jpgFunc := processMakeSuffixFunc(".jpg")
	txtFunc := processMakeSuffixFunc(".txt")
	fmt.Println(jpgFunc("test.jpg"))
	fmt.Println(txtFunc("test.txt"))
}

输出:

test.jpg
test.txt

闭包进阶示例

func processCalc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}
func processFuncCalcDemo() {
	f1, f2 := processCalc(10)
	fmt.Println(f1(1), f2(2)) //11 9
	fmt.Println(f1(3), f2(4)) //12 8
	fmt.Println(f1(5), f2(6)) //13 7
}

defer延迟执行语句

go语言中存在一种延迟执行的语句,由defer关键字标识

Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时,将延迟处理的语句按defer定义的逆序进行执行,也就是说,先被defer的语句最后被执行,最后被defer的语句,最先被执行。

举个例子:

func processDeferDemo() {
	fmt.Println("start now")
	defer fmt.Println("这是第一条defer")
	defer fmt.Println("这是第二条defer")
	defer fmt.Println("这是第三条defer")
	fmt.Println("end")
}

输出:

start now
end
这是第三条defer
这是第二条defer
这是第一条defer

由于defer语句延迟调用的特性,所以defer语句能非常方便的处理资源释放问题。比如:资源清理文件关闭解锁及记录时间等。

来看一个连接关闭的例子

func tcpSend() {
	//建立一个tcp连接
	conn, err := net.Dial("tcp", "www.baidu.com:80")
	if err == nil {
		//执行完成后 关闭连接
		defer conn.Close()
		//获取远程网络地址
		fmt.Println("remote address:", conn.RemoteAddr())
	}
	fmt.Println("erros:", err)
}

输出:

remote address: 157.148.69.74:80
erros: <nil>

defer执行时机

在Go语言的函数中return语句在底层并不是原子操作,它分为给返回值赋值和RET指令两步。而defer语句执行的时机就在返回值赋值操作后,RET指令执行前。

总的来说 defer 语句中的函数会在函数返回之前执行,但它并不会对函数的返回值产生直接影响

具体如下图所示:

defer经典案例

代码:

func f1() int {
	x := 5
	//加到延迟执行中 由于在加入时值就确定了 x = 5
	defer func() {
		x++
	}()
	//延迟执行会在return返回前执行
	return x
}

func f2() (x int) {
	defer func() {
		x++
	}()
	//在函数的最后,return 5 语句将 5 赋值给命名返回值 x。然而,在实际返回之前,defer 语句中的匿名函数会被执行,此时 x 的值会自增
	return 5
}

func f3() (y int) {
	x := 5
	defer func() {
		x++
	}()
	return x
}
func f4() (x int) {
	defer func(x int) {
		x++
	}(x)
	return 5
}
func processFuncDemo15() {
	fmt.Println(f1())
	fmt.Println(f2())
	fmt.Println(f3())
	fmt.Println(f4())
}

返回值:

5
6
5
5

defer语句中的fmt.Println()参数i值在defer出现时就已经确定下来,实际上是拷贝了一份。后面对变量i的修改不会影响fmt.Println()函数的执行

比如代码中的f1函数就是拷贝了

注意:对于指针类型参数,规则仍然适用,只不过延迟函数的参数是一个地址值,这种情况下,defer后面的语句对变量的修改可能会影响延迟函数

比如f2函数就是一个典型的影响了变量 因为它的参数是一个地址

再来一个示例:

func deferFuncReturn() (result int) {
	i := 1
	defer func() {
		result++
	}()
	return i
}

输出:

2

defer面试题

代码:

func processCalcDemo(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func processFuncDemo16() {
	a := 1
	b := 2
	defer processCalcDemo("1", a, processCalcDemo("10", a, b))
	a = 0
	defer processCalcDemo("2", a, processCalcDemo("20", a, b))
	b = 1
}

输出:

10 1 2 3
20 0 2 2
2 0 2 2
1 1 3 4

 代码解释

  1.  processFuncDemo16 函数中,定义了变量 a  b 分别赋值为 1 和 2。
  2. 在第一个延迟函数调用 defer processCalcDemo("1", a, processCalcDemo("10", a, b)) 中:
    • 首先,执行内部的函数调用 processCalcDemo("10", a, b),将参数值传递给该函数。这里会输出 "10 1 2 3",并返回结果 3。
    • 然后,执行外部的函数调用 processCalcDemo("1", a, 3),其中参数 a 的值为 1,参数 b 的值为前一个函数调用的结果 3。这里会输出 "1 1 3 4",并返回结果 4。
    • 最终,将函数调用 processCalcDemo("1", a, 4) 添加到延迟执行队列中。
  3. 接着,修改变量 a 的值为 0。
  4. 在第二个延迟函数调用 defer processCalcDemo("2", a, processCalcDemo("20", a, b)) 中:
    • 首先,执行内部的函数调用 processCalcDemo("20", a, b),将参数值传递给该函数。这里会输出 "20 0 2 2",并返回结果 2。
    • 然后,执行外部的函数调用 processCalcDemo("2", 0, 2),其中参数 a 的值为 0,参数 b 的值为前一个函数调用的结果 2。这里会输出 "2 0 2 2",并返回结果 2。
    • 最终,将函数调用 processCalcDemo("2", 0, 2) 添加到延迟执行队列中。
  5. 最后,修改变量 b 的值为 1。
  6. 函数执行完毕,开始依次执行延迟执行队列中的函数调用:
    • 先执行 processCalcDemo("2", 0, 2),输出 "2 0 2 2"。
    • 然后执行 processCalcDemo("1", 1, 4),输出 "1 1 3 4"。

需要注意的是,延迟执行的函数调用是在函数结束时按照添加顺序执行的。在添加到延迟执行队列时,会立即计算并传递参数值,但函数的实际执行会在函数结束时才发生。因此,在 defer 语句中的函数调用参数会在添加到延迟执行队列时进行计算,而不是在实际执行延迟函数时计算。这就是导致输出顺序不同于函数调用顺序的原因。

版权声明:
作者:linrux
链接:https://www.tot7.cn/technology/go/478.html
来源:阿信博客
文章版权归作者所有,未经允许请勿转载。

THE END
分享
二维码
< <上一篇
下一篇>>
文章目录
关闭
目 录