Go入门（三）之自定义函数、匿名函数、闭包、defer、作用域

最新推荐文章于 2024-09-19 13:26:16 发布
最新推荐文章于 2024-09-19 13:26:16 发布
阅读量345 收藏
点赞数 1
分类专栏： Golang 文章标签： go 函数闭包 函数 延迟调用defer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dream_ya/article/details/118529594
版权

上一篇文章> Go入门（二）之基础类型、fmt格式化、运算符、流程控制

一、自定义函数

在这里插入图片描述

1、无参无返回值

package main

import "fmt"

// 无参无返回值的函数定义
func MyFunc() {
	a := 123
	fmt.Println("a = ", a)
}

func main() {
	//函数调用
	MyFunc()
}

结果：

a =  123

2、普通参数列表

（1）有参无返回值
package main

import "fmt"

// 有参无返回值的函数定义
func MyFunc(a int) {
	fmt.Println("a = ", a)
}

func main() {
	//函数调用
	MyFunc(123)
}

结果：

a =  123
（2）不定参数列表

<1> 不定参数类型

package main

import "fmt"

func MyFunc(a int, args ...int) {
	fmt.Println("a = ", a)
	fmt.Println("长度等于", len(args))
	fmt.Println("------------------------")
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	fmt.Println("------------------------")
	for i, data := range args {
		fmt.Printf("args[%d] = %d\n", i, data)
	}
}

func main() {
	//函数调用
	MyFunc(1, 2, 3)
}

结果：

a =  1
长度等于 2
------------------------
args[0] = 2
args[1] = 3
------------------------
args[0] = 2
args[1] = 3

<2> 不定参数传递

package main

import "fmt"

func MyFunc(tmp ...int) {
	for _, data := range tmp {
		fmt.Println("data = ", data)
	}
}

func test(args ...int) {
	// 全部元素传递给MyFunc
	// MyFunc(args...)

	//只想把后2个参数传递给另外一个函数使用
	MyFunc(args[2:]...)
}
func main() {
	test(1, 2, 3, 4)
}

结果：

data =  3
data =  4

3、无参有返回值

（1）一个返回值
package main

import "fmt"

// 无参数有一个返回值
func myfunc01() int {
	return 123
}

// 给返回值起一个变量名，go推荐写法
func myfunc02() (result int) {
	return 1234
}

// 常用写法
func myfunc03() (result int) {
	result = 666
	return
}

func main() {
	fmt.Println("myfunc01 = ", myfunc01())
	fmt.Println("myfunc02 = ", myfunc02())
	fmt.Println("myfunc03 = ", myfunc03())
}

结果：

myfunc01 =  123
myfunc02 =  1234
myfunc03 =  666
（2）多个返回值
package main

import "fmt"

func myfunc01() (int, int, int) {
	return 1, 2, 3
}

// go官网推荐写法
func myfunc02() (a int, b int, c int) {
	a, b, c = 1, 2, 3
	return
}

// 常用写法
func myfunc03() (a, b, c int) {
	a, b, c = 1, 2, 3
	return
}

func main() {
	a, b, c := myfunc03()
	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
	// myfunc01()
}

结果：

a = 1, b = 2, c = 3

4、有参有返回值

package main

import "fmt"

func MyFunc01(a, b int) (max, min int) {
	if a > b {
		max = a
		min = b
	} else {
		max = b
		min = a
	}
	return
}

func main() {
	max, min := MyFunc01(10, 20)
	fmt.Printf("max = %d, min = %d\n", max, min)
}

结果：

max = 20, min = 10

二、递归函数

package main

import "fmt"

// 实现1+2+3+100
// 方式一
func test01() (sum int) {
	for i := 0; i <= 100; i++ {
		sum += i
	}
	return
}

// 方式二
func test02(i int) int {
	if i == 1 {
		return 1
	}
	return i + test02(i-1)
}

// 方式三
func test03(i int) int {
	if i == 100 {
		return 100
	}
	return i + test02(i+1)
}

func main() {
	// sum := test01()
	// sum := test02(100)
	sum := test03(100)
	fmt.Println("sum = ", sum)
}

结果：

sum =  100

三、函数类型

1、类型

package main

import "fmt"

func Add(a, b int) int {
	return a + b
}

func minus(a, b int) int {
	return a - b
}

// 函数也是一种类型， 通过type给一个函数类型起名
// FuncType它是一个函数类型
type FuncType func(int, int) int // 没有函数名字，没有{}

func main() {
	res := Add(1, 2)
	fmt.Println("res = ", res)

	// 声明一个函数类型的变量，变量名为fTest
	var fTest FuncType
	fTest = Add //是变量就可以赋值
	res = fTest(10, 20)
	fmt.Println("res1 = ", res)

	fTest = minus
	res = fTest(10, 2)
	fmt.Println("res2 = ", res)
}

结果：

res =  3
res1 =  30
res2 =  8

2、回调函数

package main

import "fmt"

type FuncType func(int, int) int

// 实现加法
func Add(a, b int) int {
	return a + b
}

func minus(a, b int) int {
	return a - b
}

// 回调函数，函数有一个参数是函数类型
// 多态，多种形态
func Calc(a, b int, fTest FuncType) (result int) {
	fmt.Println("Calc")
	result = fTest(a, b)
	return
}

func main() {
	a := Calc(1, 1, Add)
	fmt.Println("a = ", a)

	b := Calc(2, 1, minus)
	fmt.Println("b = ", b)
}

结果：

Calc
a =  2
Calc
b =  1

四、匿名函数与闭包

1、匿名函数

package main

import "fmt"

func main() {
	a := 10
	// 匿名函数
	f1 := func() {
		fmt.Println("a = ", a)
	}
	f1()

	// 给函数起别名
	type FuncType func()
	// 声明变量
	var f2 FuncType
	f2 = f1
	f2()

	// 定义匿名函数，同时调用
	func() {
		fmt.Printf("a = %d\n", a)
	}() //调用此匿名函数

	// 带参数的匿名函数
	f3 := func(i, j int) {
		fmt.Printf("i = %d, j = %d\n", i, j)
	}
	f3(1, 2)

	// 定义匿名函数，同时调用
	func(i, j int) {
		fmt.Printf("i = %d, j = %d\n", i, j)
	}(10, 20)

	// 匿名函数，有参有返回值
	x, y := func(i, j int) (max, min int) {
		if i > j {
			max = i
			min = j
		} else {
			max = j
			min = i
		}
		return
	}(10, 20)
	fmt.Printf("max = %d, min = %d\n", x, y)
}

结果：

a =  10
a =  10
a = 10
i = 1, j = 2
i = 10, j = 20
max = 20, min = 10

2、闭包

它不关心这些捕获了得变量和常量是否已经超出了作用域
所以只有闭包还在使用它，这些变量就会一直存在

package main

import "fmt"

func test01() int {
	var x int
	x++
	return x * x //函数调用完毕就释放
}

// 闭包：函数返回值为一个匿名函数
func test02() func() int {
	var x int

	return func() int {
		x++
		return x * x
	}
}

func main() {
	fmt.Println(test01())
	fmt.Println(test01())
	fmt.Println(test01())
	fmt.Println("-----------------")
	f := test02()
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
}

结果：

1
1
1
-----------------
1
4
9

五、延迟调用defer

1、defer使用

package main

import "fmt"

func main() {
	// defer延迟调用，main函数结束前调用
	defer fmt.Println("2222")
	fmt.Println("1111")
}

结果：

1111
2222

2、多个defer的执行顺序

后进先出的顺序执行

package main

import "fmt"

func test(x int) {
	fmt.Println(100 / x)
}

func main() {
	defer fmt.Println("aaaa")
	defer fmt.Println("bbbb")
	defer test(0)
	defer fmt.Println("ccc")
}

结果：

ccc
bbbb
aaaa
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.test(0x0)
        E:/MyWork/Go Projects/src/wielun666@163.com/02/17_多个defer的执行顺序.go:6 +0xbb
main.main()
        E:/MyWork/Go Projects/src/wielun666@163.com/02/17_多个defer的执行顺序.go:14 +0x193
exit status 2

3、defer和匿名函数结合使用

提前把参数传递进去了，只是没有进行调用

package main

import "fmt"

// func main() {
// 	a := 10

// 	defer func() {
// 		fmt.Println("a = ", a)
// 	}()

// 	a = 20
// 	fmt.Println("a = ", a)
// }

func main() {
	a := 10
	defer func(a int) {
		fmt.Println("aaa = ", a)
	}(a)
	a = 20
	fmt.Println("a = ", a)
}

结果：

a =  20
aaa =  10

六、获取命令行参数

package main

import (
	"fmt"
	"os"
)

func main() {
	list := os.Args
	n := len(list)
	fmt.Println("n = ", n)

	for i := 0; i < n; i++ {
		fmt.Printf("list[%d] = %s\n", i, list[i])
	}
	fmt.Printf("-------------\n")
	for i, data := range list {
		fmt.Printf("range list[%d] = %s\n", i, data)
	}
}

结果：

> go build .\19_获取命令行参数.go
> .\19_获取命令行参数.exe helo wielun
n =  3
list[0] = E:\MyWork\Go Projects\src\wielun666@163.com\02\19_获取命令行参数.exe
list[1] = hello
list[2] = wielun
-------------
range list[0] = E:\MyWork\Go Projects\src\wielun666@163.com\02\19_获取命令行参数.exe
range list[1] = hello
range list[2] = wielun

七、不用作用域同名变量

package main

import "fmt"

var a byte //全局变量

func main() {
	var a int //局部变量

	fmt.Printf("1: %T\n", a) //int
	{
		var a float32
		fmt.Printf("2: %T\n", a) //float32
	}
	test()
}

func test() {
	fmt.Printf("3: %T\n", a) //uint8,就是byte
}

结果：

1: int
2: float32
3: uint8

下一篇文章> Go入门（四）之工程管理、复合类型

Wielun
关注
专栏目录
go 中的 defer 使用及其规则
Congying-Wang的博客
05-27 4584
文章目录1 defer 定义1.1 简单示例1.2 具体示例2 defer 常用场景3 defer 规则3.1 当申明defer 时，参数就已经解析了3.2 defer执行顺序为先进后出3.3 defer可以读取有名返回值 1 defer 定义 defer 英文原意： vi. 推迟；延期；服从 vt. 使推迟；使延期。 defer的思想类似于C++中的析构函数，不过Go语言中“析构”的不是对象...
Go基础编程：自定义函数
dodod2012的专栏
07-31 302
原文地址：https://blog.csdn.net/tennysonsky/article/details/78147600 定义格式 函数构成代码执行的逻辑结构。在Go语言中，函数的基本组成为：关键字func、函数名、参数列表、返回值、函数体和返回语句。 Go 语言函数定义格式如下： func FuncName(/*参数列表*/) (o1 type1, o2 type2/*返回类型*...
GO语言defer用法总结
最新发布
IT杨秀才的博客
09-19 1046
defer顾名思义，延迟。它是go语言中的一个关键字，主要用在函数或方法前面，作用是用于函数和方法的延迟调用，在语法上，defer与普通的函数调用没有什么区别。在使用上非常简单，只需要弄清楚以下几点即可：延迟的函数的什么时候被调用？函数return的时候发生panic的时候延迟调用的语法规则defer关键字后面表达式必须是函数或者方法调用延迟内容不能被括号括起来。
Go语言之自定义函数
gentelyang的博客
01-14 1202
函数构成代码执行的逻辑结构。在Go语言中，函数的基本组成为：关键字func、函数名、参数列表、返回值、函数体和返回语句。 Go语言函数定义格式如下： 返回类型： ①　上面返回值声明了两个变量名o1和o2(命名返回参数)，这个不是必须，可以只有类型没有变量名  ②　如果只有一个返回值且不声明返回值变量，那么你可以省略，包括返回值的括号  ③　如果没有返回值，那么就直接省略最后的返回信息  ...
Go语言--自定义函数
m0_73537205的博客
07-04 624
func:函数由关键字func开始声明FuncName:函数名称，根据约定，数名首字母小写即为private，大写即为 public.参数列表:函数可以有0个或多个参数，参数格式为:变量名 类型，如果有多个参数通过逗号分隔，不支持默认参数，即不支持 a int =10返回类型:①上面返回值声明了两个变量名 o1和 o2 (命名返回参数)，这个不是必须，可以只有类型没有变量名;②如果只有一个返回值且不声明返回值变量，可以省略，包括返回值的括号;③如果没有返回值，就直接省略最后的返回信息;
Go defer函数陷阱与闭包理解
Go语言中的`defer`函数是一种强大的工具，它允许我们在函数返回之前执行一段代码。`defer`语句的执行顺序不同于常规函数调用，它遵循“后进先出”（LIFO）的原则，即最后声明的`defer`会在函数返回时最先执行。这在...
Go使用defer函数要注意的几个点
09-18
2. **闭包与变量捕获**：`defer`函数中的闭包会捕获其作用域内的变量，且捕获的是变量的引用而非值。这意味着如果在`defer`函数执行前变量被修改，闭包内部将看到修改后的值。 ```go func main() { var a = 1 var ...
GoLang学习笔记：匿名函数与闭包在sharding-jdbc中的应用
闭包是Go语言中另一个强大的工具，它能够记住其定义时的作用域，即使在函数执行完成后仍然可以访问。这对于处理异步操作或者延迟执行的任务非常有帮助。在Sharding-JDBC中，`Defer`关键字可以结合闭包实现优雅的资源...
go代码-Go 函数作用域
07-14
在 Go 语言中，函数作用域是编程中一个至关重要的概念，它决定了变量的可见性和生命周期。本篇文章将深入探讨 Go 语言中的函数作用域及其相关的知识点。 首先，我们要了解 Go 语言中的变量声明。变量可以在不同的...
Go语言入门-函数function类型探索
syouya.shiraki's blog
05-12 757
Go语言入门-函数-function 定义 Go语言中函数面向过程编程中最小的模块单元，具备输入、输出的功能，完成从输入到输出的转换，主要是把业务逻辑或者算法分解成具备单一功能，独立解耦的程序块。 函数签名 函数的签名包括：关键字 “func”、函数名称、函数参数、函数返回值。 Go语言的函数定义格式： //多个返回值，需要用括号包裹起来 func functionName([parameterList]) ([returnTypes]) { ... body ... } //返
Go 语言使用自定义函数
m0_64432438的博客
11-29 492
Go 语言使用自定义函数
go defer的作用域
ckx178的博客
03-19 700
总是觉得不去敲出来验证，心里始终有疑问，看到一段代码，主协程里for循环里面defer挂起关闭，是在for结束前关闭还是主协程关闭前执行关闭？ 还是对defer理解的不深刻，查查看标准库文档，有没有，于是自己动手丰衣足食： func main() { file, _ := os.OpenFile("d:/t1.txt", os.O_WRONLY|os.O_APPEND|os.O_CREA...
Go defer语句&作用域
franky专栏
03-05 3059
1 defer 语句 defer是Go语言提供的关键字，用于资源的释放，会在函数返回之前进行调用。 defer语句是Go中一个非常有用的特性，可以将一个方法延迟到包裹该方法的方法返回时执行，在实际应用中，defer语句可以充当其他语言中try…catch…的角色，也可以用来处理关闭文件句柄等收尾操作。 1.1 defer 执行 func main() { //defer 语句 deferDem...
go defer
摔断翅膀的鸟人
04-28 145
go语言的defer函数，很强大，可以说defer绝大多数情况下扮演的是清道夫或者擦屁股的角色； defer 是定义一种行为，当程序执行范围脱离与当前defer的作用域时，会按照该作用域内“后定义先执行”的顺序调用defer。 有点类似C++中，我们经常定义某些自动操作类，在跳出该操作类对象作用域时，会执行到析构函数，从而达到清理资源的作用。 func CopyFile(dst, src ...
Go语言之延迟调用函数defer
zhghost的专栏
07-18 489
写在前面的话：在接触defer之后，觉得Go的这一特性很好，有点类似于C++的析构函数，不过它们却有很大的不同。主要的区别点是defer实现在函数里面，作用域也是在函数里...
Go语言的匿名函数与闭包
hello_bravo_的博客
05-08 4623
匿名函数:由一个不带函数名的函数声明和函数体组成func(a,b int,z float64)bool{ return a*b<int(z) }匿名函数可以直接赋值给一个变量或直接执行闭包: 概念: 闭包是可以包含自由变量（未绑定到特定对象）的代码块，这些变量不在这个代码块内或者任何全局上下文中定义，而是在定义代码块的环境中定义。要执行的代码块(由于自由变量包含在代码块中，所以这些自由变量
【GO语言04-1】Go语言中关于函数定义、闭包函数、作用域、defer关键字详解
量化Mike
02-04 852
Go语言中的功能封装是通过函数进行的，不同结构体之间可以通过接口来进行统一，再结合反射特性就可以开发大型的、复杂的项目。 一、函数的定义 Go语言是支持面向对象编程的，但是函数才是Go语言的基本组成元素。 Go语言的函数分为具名函数、匿名函数 //具名函数 func main(a int) int { return a * a } main(11) //匿名函数 var nua = func(a int) int { return a * a } nua(12) 二、闭包 匿名函数可以赋值给一个变量
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wielun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值