Featured image of post golang学习十：函数
Go

golang学习十：函数

函数

  • 函数:一段代码块
  • 所有的流程控制代码和业务代码都只能写在函数内部
  • 为什么使用函数:
    • 把一个功能提出作为一个函数便于后期维护,结构清晰
  • 函数声明的语法
    • 函数声明后不会执行,必须调用后才会执行
1
2
3

func 函数名(参数列表) 返回值{
  //函数体
}
  • 函数调用的语法
1

返回值:=函数名(参数)

无参数无返回值函数

  • 函数可以有参数也可以没有参数,可以有返回值也可以没有返回值
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func main() {
	demo1()
}
func demo1(){
	fmt.Println("执行demo1函数")
}

//上面代码等同于
//func main(){
//	fmt.Println("执行demo1函数")
//}

有参数函数

  • 函数的参数可以有多个,且每个参数类型都可以不同
  • 参数表示调用函数方想要给函数内部传递的值,给函数使用的.
  • 声明函数时的参数叫做形参数,调用函数时参数叫做实参
1
2
3
4
5
6
7
8

func main() {
	i:=5
	s:="msr"
	show(s,i)
}
func show(name string,age int){
	fmt.Println("姓名:",name,"年龄",age)
}

有返回值函数

  • 函数的返回值是给调用方返回的数据,给调用方使用的.
  • 具有返回值的函数,必须要有return
1
2
3
4
5
6
7

func main() {
	a, b := 1, 2
	fmt.Println(add(a,b))
}
func add(c, d int) int {
	return c + d
}
  • 也可以在返回值类型前面添加变量,return关键字后不写内容,表示变量是什么返回值什么
1
2
3
4
5
6
7
8
9

func main() {
	a, b := 1, 2
	fmt.Println(add2(a,b))
}

func add2(c, d int) (sum int) {
	sum = c + d
	return
}

多返回值函数

  • 在Go语言中每个函数声明时都可以定义成多返回值函数
  • Go语言中所有的错误都是通过返回值返回的
  • 声明多返回值函数的语法
1
2
3

func 函数名(参数列表) (返回值,返回值){
  //函数体
}
  • 调用函数的语法
1

变量,变量:=函数名(参数)
  • 调用函数时如果不想接收可以使用下划线占位
1

变量,_:=函数名(参数)
  • 理论上函数返回值个数可以无限多个,但是一般不去定义特别多个返回值(用结构体代替多返回值)

代码演示

  • 函数的返回值可以不接收,表示执行函数
  • 函数的返回值如果接收,用于接收返回值的变量个数与返回值个数相同
  • 不想接收的使用占位符(_)占位
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

func main() {
	//不接收函数返回值
	demo()

	//每个返回值都接收
	a, b := demo()
	fmt.Println(a, b)

	//不希望接收的返回值使用下划线占位
	c, _ := demo()
	fmt.Println(c)
}

func demo() (string, int) {
	return "msr", 17
}
  • 多返回值函数也可以给返回值定义变量,return后面就不需要编写内容
1
2
3
4
5

func demo() (name string, age int) {
	name = "nsr"
	age = 17
	return
}

可变参数函数

  • Go语言支持可变参数函数
  • 可变参数指调用参数时,参数的个数可以是任意个
  • 可变参数必须在参数列表最后的位置,在参数名和类型之间添加三个点表示可变参数函数
1
2
3

func 函数(参数,参数,名称 ... 类型 ){
	//函数体
}
  • 输出语句就是可变参数函数,源码如下
1
2
3

func Println(a ...interface{}) (n int, err error) {
	return Fprintln(os.Stdout, a...)
}
  • 声明函数时,在函数体把可变参数当作切片使用即可

代码示例

  • 声明可变参数声明与调用
1
2
3
4
5
6
7
8
9

func main() {
	demo("看书", "写代码", "看抖音视频")
}

func demo(hover ... string) {
	for a, b := range hover {
		fmt.Println(a, b)
	}
}
  • 可变参数必须存在其他参数后面,一个函数不能有多个可变参数.
    • 因为前面普通参数个数是确定的,编译器知道,哪个实参给哪个形参
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func main() {
	demo("张三", "看书", "写代码", "看抖音视频")
}

func demo(name string, hover ... string) {
	fmt.Println(name, "的爱好是")
	for a, b := range hover {
		fmt.Println(a, b)
	}
}

匿名函数

  • 匿名函数就是没有名称的函数
  • 正常函数可以通过名称多次调用,而匿名函数由于没有函数名,所以大部分情况都是在当前位置声明并立即调用(函数变量除外)
  • 匿名函数声明完需要调用,在函数结束大括号后面紧跟小括号
1
2
3

func (){
  
}()//括号表示调用
  • 匿名函数都是声明在其他函数内部

匿名函数演示

  • 无参数匿名函数
1
2
3
4
5

  func main(){
     func(){
        fmt.Println("这是匿名函数")
     }()//括号表示调用
  }
  • 有参数匿名函数
1
2
3
4
5

func main() {
   func(s string) {
      fmt.Println(s, "这是匿名函数")
   }("传递参数") //调用时传递参数
}
  • 有参数有返回值匿名函数
1
2
3
4
5
6
7

func main() {
	r := func(s string) int {
		fmt.Println(s, "这是匿名函数")
		return 110
	}("传递参数") //调用时传递参数
	fmt.Println(r)
}

函数变量

  • 在Go语言中函数也是一种类型,函数有多少种形式,函数变量就有多少种写法
1
2
3
4

	var a func()           //无参数无返回值
	var b func(int)        //有一个int类型参数
	var c func(int) string //有一个int类型参数和string类型返回值
	fmt.Println(a, b, c)   //输出:<nil> <nil> <nil>
  • 定义完函数变量后,可以使用匿名函数进行赋值.也可以使用已经定义好的函数进行赋值
  • 函数变量定义以后与普通函数调用语法相同,变量名就是普通函数声明的函数名
 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
28
29

func main() {
	var a func()
	a = func() {
		fmt.Println("执行函数")
	}   //注意此处没有括号,有括号表示调用函数,变量a就表示接收函数返回值
	a() //调用函数

	/*
	也可以使用短变量方式定义函数变量
	等效于
	func b(s string){
		//...
	}
	 */
	b := func(s string) {
		fmt.Println("执行第二个函数")
	}
	b("参数")

	//使用定义好的函数
	d := c
	d()
	//函数名称c也是一个变量
	c()
}

func c() {
	fmt.Println("c函数")
}
  • 函数类型变量是除了slice、map、channel、interface外第五种引用类型
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func main() {
	var a func()
	a = b
	a()
	var c func()
	c = a
	c()
	fmt.Printf("%p %p", a, c)//输出地址相同
}

func b() {
	fmt.Println("b")
}

函数作为参数或返回值

  • 变量可以作为函数的参数或返回值类型.而函数既然可以当做变量看待,函数变量也可以当做函数的参数或返回值
  • 函数作为参数时,类型写成对应的类型即可
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func main() {
	a(func(s string) {
		fmt.Println(s)
	})
}

func a(b func(s string)) {
	fmt.Println("a执行")
	b("传递给s的内容")
}
  • 函数作为返回值
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

func main() {
	//此时result指向返回值函数.
	result := a()
	//调用函数,才能获取结果
	fmt.Println(result())
}

func a() func() int {
	return func() int {
		return 110go
	}
}

golang学习一：从环境配置开始到HelloWorld入门 golang学习二：golang自带的工具 olang学习三：golang基础语法 golang学习四：流程控制 golang学习五：常用数学函数与数组 golang学习六：for循环 golang学习七：goto和label golang学习八：切片 golang学习九：sort包、map、双向链表、双向循环链表 golang学习十：函数 golang学习十一：包的访问权限、变量作用域、闭包 golang学习十二：值传递和引用传递 golang学习十三：结构体 golang学习十四：golang中的面向对象 golang学习十五：错误异常处理 golang学习十六：文件操作 golang学习十七：反射 golang学习十八：XML操作 golang学习十九：日志 golang学习二十：golang并发编程入门 golang学习二十一：select和GC

Golang
Licensed under CC BY-NC-SA 4.0