快速入门GO语言之Lesson01-函数

最新推荐文章于 2026-07-24 15:19:37 发布

原创最新推荐文章于 2026-07-24 15:19:37 发布 · 653 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

GO 语言

本文深入讲解Go语言中的函数定义、使用、递归及匿名函数，包括函数的基本语法、参数传递、返回值处理、递归调用及匿名函数的应用实例。

一、GO语言函数定义

Go 语言最少有个 main() 函数。可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。函数声明告诉了编译器函数的名称，返回类型，和参数。Go 语言标准库提供了多种可动用的内置的函数。

func function_name( [parameter list] ) [return_types] {
   函数体
}
func：函数由 func 开始声明
function_name：函数名称，函数名和参数列表一起构成了函数签名。
parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
函数体：函数定义的代码集合。
From https://www.runoob.com/

二、带参与无参函数

2.1 函数定义

定义函数时，在函数后面()定义的参数叫做形参，参数传递只能由实参传递给形参，单向传递。

无参数无返回值函数
func MyFunc() {
	a := 10
	fmt.Printf("a = %d\n", a)
}

有参数无返回值函数
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

有参数无返回值函数
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

func MyFunc02(b, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}

不定参数列表
...int 不定参数类型
传递的实参可以是0或者多个
固定参数一定要传参数，固定参数可以不传
接收main()函数的
func MyFunc03(args ...int) {
	//获取用户参数传递的个数
	fmt.Printf("len(args) = %d\n", len(args))
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	fmt.Printf("*****************\n")
	//返回两个值，第一个是下标，第二个是下标所对应的数
	for i, data := range args {
		fmt.Printf("args[%d] = %d\n", i, data)
	}
}

2.2 完整实践代码

package main

import "fmt"

// 1、函数定义声明
// Go 语言最少有个 main() 函数。
// 可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
// 函数声明告诉了编译器函数的名称，返回类型，和参数。
// Go 语言标准库提供了多种可动用的内置的函数。

//2、普通参数列表
//定义函数时，在函数后面()定义的参数叫做形参
//参数传递，只能由实参传递给形参，单向传递

//无参数无返回值函数
func MyFunc() {
	a := 10
	fmt.Printf("a = %d\n", a)
}

//有参数无返回值函数
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

func MyFunc02(b, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}

//3、不定参数列表
//...int 不定参数类型
//传递的实参可以是0或者多个
//固定参数一定要传参数，固定参数可以不传
//接收main()函数的
func MyFunc03(args ...int) {
	//获取用户参数传递的个数
	fmt.Printf("len(args) = %d\n", len(args))
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	fmt.Printf("*****************\n")
	//返回两个值，第一个是下标，第二个是下标所对应的数
	for i, data := range args {
		fmt.Printf("args[%d] = %d\n", i, data)
	}
}

//接收Transform(args ...int)传过来的参数并打印
func MyFunc04(temp ...int) {
	for _, data := range temp {
		fmt.Printf("data = %d\n", data)
	}
}

//接收Transform(args ...int)传过来的参数并打印
func MyFunc05(temp ...int) {
	for _, data := range temp {
		fmt.Printf("data = %d\n", data)
	}
}

//传送参数到MyFunc04(temp ...int)和MyFunc05(temp ...int)
func Transform(args ...int) {
	//全部元素传递给MyFunc04()
	MyFunc04(args...)

	//[1到3]部分元素传递给MyFunc05()
	MyFunc05(args[1:3]...)
}

func main() {
	//调用MyFunc（）函数
	MyFunc()
	//调用MyFunc01（）函数
	MyFunc01(20)
	MyFunc02(30, 40)

	//调用MyFunc03（）函数
	MyFunc03(1, 2, 3, 4, 5, 6, 7)

	//调用Transform() 函数
	Transform(1, 2, 3, 4, 5)
}
运行结果
a = 10
b = 20
b = 30,c = 40
len(args) = 7
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4
args[4] = 5
args[5] = 6
args[6] = 7
*****************
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4
args[4] = 5
args[5] = 6
args[6] = 7
data = 1
data = 2
data = 3
data = 4
data = 5
data = 2
data = 3

三、自定义函数

3.1 函数定义

函数声明包括函数名、形式参数列表、返回值列表（可省略）以及函数体。
无参有返回值：只有一个返回值。
有返回值的函数，需要通过return中断函数，通过return返回。
有参返回值，可以有多个返回值。

func 函数名(形式参数列表)(返回值列表){
    函数体
}

无参数无返回值函数
func MyFunc() {
	a := 10
	fmt.Printf("a = %d\n", a)

有参数无返回值函数
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

有参数无返回值函数
func MyFunc02(b, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}

返回一个int 10
func MyFunc06() int {
	return 10
}

给返回值起一个变量名
func MyFunc07() (result int) {
	return 10
}

返回多个参数
func MyFunc08() (a int, b int, c int) {
	a, b, c = 1, 2, 3
	return
}

3.2 完整实践代码

package main

import "fmt"

/* 1、函数定义声明
函数声明包括函数名、形式参数列表、返回值列表（可省略）以及函数体。
func 函数名(形式参数列表)(返回值列表){
    函数体
}*/

/*2、普通参数函数
定义函数时，在函数后面()定义的参数叫做形参
参数传递，只能由实参传递给形参，单向传递
*/

//无参数无返回值函数
func MyFunc() {
	a := 10
	fmt.Printf("a = %d\n", a)
}

//有参数无返回值函数
func MyFunc01(b int) {
	fmt.Printf("b = %d\n", b)
}

//有参数无返回值函数
func MyFunc02(b, c int) {
	fmt.Printf("b = %d,c = %d\n", b, c)
}

//接收main()传来的不定参数
func MyFunc03(args ...int) {
	//获取用户参数传递的个数
	fmt.Printf("len(args) = %d\n", len(args))
	for i := 0; i < len(args); i++ {
		fmt.Printf("args[%d] = %d\n", i, args[i])
	}
	fmt.Printf("*****************\n")
	//返回两个值，第一个是下标，第二个是下标所对应的数
	for i, data := range args {
		fmt.Printf("args[%d] = %d\n", i, data)
	}
}

//接收Transform(args ...int)传来的参数
func MyFunc04(temp ...int) {
	for _, data := range temp {
		fmt.Printf("data = %d\n", data)
	}
}

//接收Transform(args ...int)传来的参数
func MyFunc05(temp ...int) {
	for _, data := range temp {
		fmt.Printf("data = %d\n", data)
	}
}

//传递参数给MyFunc04(temp ...int)和MyFunc05(temp ...int)
func Transform(args ...int) {
	//全部元素传递给MyFunc04()
	MyFunc04(args...)
	//[1到3]部分元素传递给MyFunc05()
	MyFunc05(args[1:3]...)
}

/*3、返回值函数
无参有返回值：只有一个返回值
有返回值的函数，需要通过return中断函数，通过return返回
有参返回值，可以有多个返回值
*/

//返回一个int 10
func MyFunc06() int {
	return 10
}

//给返回值起一个变量名
func MyFunc07() (result int) {
	return 10
}

//返回多个参数
func MyFunc08() (a int, b int, c int) {
	a, b, c = 1, 2, 3
	return
}

func main() {
	//调用MyFunc（）函数
	MyFunc()
	//调用MyFunc01（）函数
	MyFunc01(20)
	MyFunc02(30, 40)
	fmt.Printf("*****************\n")
	//调用MyFunc03（）函数
	MyFunc03(1, 2, 3, 4, 5, 6, 7)
	fmt.Printf("*****************\n")
	//调用Transform() 函数
	Transform(1, 2, 3, 4, 5)
	fmt.Printf("*****************\n")
	//调用MyFunc06（）函数
	var a int
	a = MyFunc06()
	fmt.Printf("a = %d\n", a)
	fmt.Printf("*****************\n")
	//调用MyFunc07（）函数
	fmt.Printf("result = %d\n", MyFunc07())
	fmt.Printf("*****************\n")
	//调用MyFunc08（）函数
	d, e, f := MyFunc08()
	fmt.Printf("a = %d,b = %d,c = %d\n", d, e, f)
}

运行结果
a = 10
b = 20
b = 30,c = 40
*****************
len(args) = 7
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4
args[4] = 5
args[5] = 6
args[6] = 7
*****************
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4
args[4] = 5
args[5] = 6
args[6] = 7
*****************
data = 1
data = 2
data = 3
data = 4
data = 5
data = 2
data = 3
*****************
a = 10
*****************
result = 10

四、递归函数

4.1 递归函数的定义：通过调用自己实现递归。

4.2 普通函数与递归函数的调用过程对比（图片来自某视频教程）

递归函数实现递归调用
普通函数实现递归调用

4.3实践代码

package main

import "fmt"

func test(a int) {
	if a == 1 {
		fmt.Println("a = ", a)
		return //终止函数条用
	}
	test(a - 1) //调用函数本身
	fmt.Println("a = ", a)
}
func main() {
	test(3)
	fmt.Println("main")
}
运行结果
a =  1
a =  2
a =  3
main

五、匿名函数

5.1 匿名函数的定义

匿名函数没有函数名，只有函数体。函数可以作为一种类型被赋值给变量，匿名函数也往往以变量方式被传递。
匿名函数经常被用于实现回调函数和闭包等。

匿名函数，没有函数名字和函数定义以及调用
	f1 := func() {
		fmt.Println("a = ", a)
		fmt.Println("str = ", str)
	}
	f1() //执行函数


```go
定义匿名函数，同时调用
	func() {
		fmt.Printf("a = %d,str = %s\n", a, str)
	}() //后面的()代表调用此匿名函数

定义带参数的匿名函数，同时调用
	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("x = %d,y = %d\n", x, y)

5.2 实践代码

package main

import "fmt"

func main() {
	a := 10
	str := "mike"
	//匿名函数，没有函数名字和函数定义以及调用
	f1 := func() {
		fmt.Println("a = ", a)
		fmt.Println("str = ", str)
	}
	f1() //执行函数

	//给一个函数起别名
	type funcType func() //函数没有参数，没有返回值
	//声明变量
	var f2 funcType
	f2 = f1
	f2()

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

	//定义带参数的匿名函数，同时调用
	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("x = %d,y = %d\n", x, y)
}

运行结果
a =  10
str =  mike
a =  10
str =  mike
a = 10,str = mike
i = 10,j = 20
x = 20,y = 10

标签

#go