【30天熟悉Go语言】9 Go函数全方位解析

我会带着你远行 2024-04-23 15:57 18阅读 0赞

> **作者**：[秃秃爱健身][Link 1]，多平台博客专家，某大厂后端开发，个人IP起于源码分析文章 ?。  
> **源码系列专栏**：[Spring MVC源码系列][Spring MVC]、[Spring Boot源码系列][Spring MVC]、[SpringCloud源码系列（含：Ribbon、Feign）][SpringCloud_Ribbon_Feign]、[Nacos源码系列][Nacos]、[RocketMQ源码系列][RocketMQ]、[Spring Cloud Gateway使用到源码分析系列][Spring Cloud Gateway]、[分布式事务Seata使用到源码分析系列][Seata]、[JUC源码系列][JUC]  
> **基础系列专栏**：[30天熟悉GO语言（建设中）][30_GO]  
> 码文不易，如果感觉博主的文章还不错，请点赞?、收藏 ⭐️支持一下博主哇 ?  
> **联系方式**：Saint9768，加我进技术交流群，一起学习进步?、freedom✈️?

#### 文章目录 ####

*  一、前言
 *  二、函数
 *   *  1、函数简介
     *   *  1）函数是什么？
         *  2）为什么要使用函数？
         *  3）函数的特点？
     *  2、函数的声明和使用
     *   *  1）函数声明
         *   *  函数名不支持重载
             *  1> 返回多个值 -- 返回值无名称
             *  2> 返回多个值 -- 返回值有名称
         *  2）函数调用
     *  3、函数参数
     *   *  1）值传递
         *  2）引用传递
         *  3）不定参数 / 可变参数
     *  4、函数嵌套/递归使用
     *   *  1）函数嵌套使用
         *   *  不定参不能直接传递给另外一个不定参
         *  2）递归函数
     *  5、匿名函数
     *   *  1）赋值给变量
         *  2）构造时直接调用
     *  6、函数类型
     *  7、Go内置函数
 *  三、总结
 *   *  对比Java来看

## 一、前言 ##

![在这里插入图片描述][26456da6bcf74d8ab70094e321fbd199.png]

Go系列文章：

> 1.  [GO开篇：手握Java走进Golang的世界][GO_Java_Golang]
> 2.  [2 Go开发环境搭建、Hello World程序运行][2 Go_Hello World]
> 3.  [3 Go编程规约和API包][3 Go_API]
> 4.  [4 Go的变量、常量、运算符][4 Go]
> 5.  [5 Go 基本数据类型][5 Go]
> 6.  [6 Go 复杂数据类型之指针][6 Go]
> 7.  [7 Go流程控制之分支结构if、switch][7 Go_if_switch]
> 8.  [8 Go流程控制之循环结构for range、goto、break、continue][8 Go_for range_goto_break_continue]

**Go专栏传送链接：[https://blog.csdn.net/saintmm/category\_12326997.html][30_GO]**

## 二、函数 ##

### 1、函数简介 ###

#### 1）函数是什么？ ####

函数是一个基本的代码块，是用于完成某一功能的程序指令集；可以对特定的功能进行提取，形成一个代码片段，这个代码片段即函数。

我们可以通过函数划分不同的功能，逻辑上每个函数执行的是指定的任务。

#### 2）为什么要使用函数？ ####

提高代码的复用性，减少代码的冗余，提高代码的可维护性。

#### 3）函数的特点？ ####

*  支持可变参数
 *  支持多返回值
 *  支持匿名函数
 *  函数也是一种数据类型，可以赋值给变量
 *  不支持函数的重载（`overload`），即：一个包不能有两个名字一样的函数
 *  不支持嵌套（`nested`），即：一个包不能有两个名字一样的函数

### 2、函数的声明和使用 ###

#### 1）函数声明 ####

**函数的定义格式如下：**

func name( [parameter_list] ) [return_types] {
        
       函数体
    }

*  函数`由`func关键字声明，包含一个函数名、参数列表、返回值列表和函数体。
    
     *  左大括号要和func关键字在一行，不能另起一行。
 *  name：函数名称，只能定义一次，函数名称是唯一的，**不支持重载**
    
     *  函数名命名规范：驼峰命名
        
         *  首字母不能是数字；
         *  首字母大写该函数可以被本包文件和其它包文件使用（类似Java方法的public权限） 
         *  首学母小写只能被本包文件使用，其它包文件不能使用（类似Java方法的private权限） 
 *  parameter\_list：参数列表，指定参数类型、参数之间的顺序、参数个数；
    
     *  参数类型在参数名之后，函数可以没有参数、多个参数。
     *  当多个连续的参数是同一类型，除了最后一个参数写参数类型之外，可以参数都可以省略。
 *  return\_types：返回类型列表，函数可以返回任意数量的返回值；
    
     *  返回多个值时，多返回值必须用括号括起来，并以逗号隔开。
     *  返回单个值时，直接相应的返回值数据类型。
     *  如果函数没有返回值，返回类型列表可以省略。
 *  函数体：代码集合。

**示例1：两数相加**

func addAndFormat(num1, num2 int) int {
        
    	sum := num1 + num2
    	return sum
    }

**示例2：两数相加，返回相加结果和结果说明**

func addAndFormat(num1, num2 int, format string) (int, string) {
        
    	sum := num1 + num2
    	return sum, fmt.Sprintf(format, sum)
    }

##### 函数名不支持重载 #####

![在这里插入图片描述][21126b58c0424aaf914ca0dd5a8708ea.png]

##### 1> 返回多个值 – 返回值无名称 #####

**格式：**

func name(arg1 T, arg2 T) (T, T) {
        
            ...
            return r1, r2
    }

**特点：**

*  当需要返回两个值及以上时，返回类型用小括号包裹，逗号分隔。
 *  return语句中携带多个返回值。

##### 2> 返回多个值 – 返回值有名称 #####

**格式：**

func name(arg1 T, arg2 T) (r1 T, r2 T) {
        
            ...
            return
    }

**特点：**

*  返回值类型指定名称后，return语句中，可以不带值，也可以都带上。
 *  不过，当返回值有了名称之后，即使是只有一个返回类型，也需要用小括号包裹。

**return可以不用携带值的原因？**

*  因为等价于在返回时，初始化好了返回值；
 *  以上面的格式来看，`r1` 和 `r2` 是两个初始化的变量；
    
     *  在函数运算中，只要将返回结果存入`r1` 和 `r2`中；
     *  如果不存，也可以选择在return语句携带多个返回值。

#### 2）函数调用 ####

函数可以被多次调用，在函数调用时传递的参数为实际参数（`实参`） ，其有具体的值，用来给函数形式参数（`形参`） 传递数据。

**格式：**

r1, r2 := name(param1, param2, param3)

*  格式中，r1, r2表示两个返回值；param1, param2, param3表示三个参数。

如果接收多个值时，某个值不想使用，可以选择使用关键字`_`替代，表示不使用这个返回值。

r1, _ := name(param1, param2, param3)

**以函数声明中的示例2为例：**

**1> 返回值全部接收：**

package main
    
    import "fmt"
    
    func main() {
        
    	format := "two num add, the result is : %d "
    	sum, str := addAndFormat(1, 2, format)
    	fmt.Println(sum)
    	fmt.Println(str)
    
    }
    
    // 两数相加，返回相加结果和结果说明**
    func addAndFormat(num1, num2 int, format string) (int, string) {
        
    	sum := num1 + num2
    	return sum, fmt.Sprintf(format, sum)
    }

**控制台输出：**  
![在这里插入图片描述][d965aad514f84b199e60fdaaf1e13c60.png]

**2> 只接收一个返回值：**

package main
    
    import "fmt"
    
    func main() {
        
    	format := "two num add, the result is : %d "
    	sum, _ := addAndFormat(1, 2, format)
    	fmt.Println(sum)
    }

### 3、函数参数 ###

#### 1）值传递 ####

**Go语言中，基本数据类型和数组默认都是值传递的**，即：进行值拷贝；在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改时，将不会影响到原来的值。

**示例：定义一个swap函数，用于交换两个int类型数据的值**

package main
    
    import "fmt"
    
    func main() {
        
    	a := 3
    	b := 6
    	fmt.Printf("交换前 a 的值为 : %d\n", a)
    	fmt.Printf("交换前 b 的值为 : %d\n", b)
    
    	swap(a, b)
    	fmt.Printf("交换后 a 的值为 : %d\n", a)
    	fmt.Printf("交换后 b 的值为 : %d\n", b)
    }
    
    // 两值交换
    func swap(x, y int) int {
        
    	var temp int
    
    	temp = x
    	x = y
    	y = temp
    
    	return temp
    }

**控制台输出：**  
![在这里插入图片描述][d0416533a9304f10a4547feab22704f0.png]

调用swap()函数交换a，b值，交换前后 a，b的值没有改变；

**所以值传递不会改变传入函数实参的值，它只是复制一份数据用于函数体的执行。**

#### 2）引用传递 ####

如果希望在函数内的变量能修改函数外的变量，可以传入变量的地址 `&`，函数内以指针的方式操作变量；从效果来看类似`引用传递`。

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    	a := 3
    	b := 6
    	fmt.Printf("交换前 a 的值为 : %d\n", a)
    	fmt.Printf("交换前 b 的值为 : %d\n", b)
    	
    	swap(&a, &b)
    	fmt.Printf("交换后 a 的值为 : %d\n", a)
    	fmt.Printf("交换后 b 的值为 : %d\n", b)
    }
    
    // 两值交换
    func swap(x, y *int) int {
        
    	var temp int
    
    	temp = *x
    	// 将y地址上的值复制到x的地址上
    	*x = *y
    	*y = temp
    
    	return temp
    }

**控制台输出：**  
![在这里插入图片描述][7b73c71168564f8e8843339286d0b919.png]

**PS：**

*  无论是值传递，还是引用传递，传递给函数的都是变量的副本；不过，值传递的是值的拷贝，引用传递的是地址的拷贝。
    
     *  一般而言，地址拷贝更为高效。值拷贝的效率取决于拷贝对象的大小，对象越大，性能越低。
 *  map、slice、chan、指针、interface默认以引用的方式传递。

#### 3）不定参数 / 可变参数 ####

不定参数传值指：函数的参数类型固定、参数数量不固定；Go语言中可变参数本质上是 `slice`，并且该 slice 只能有一个，且必须是最后一个。

// 0个或多个参数
    func myfunc1(args ...int) {
        
    }
    
    // 1个或多个参数
    func add(a int, args…int) int {
        
    }
    
    // 2个或多个参数
    func add(a int, b int, args…int) int {
        
    }

*  注意：其中 `args` 是一个slice，我们可以通过 `arg[index]` 依次访问所有参数，通过 `len(arg)` 来判断传递参数的个数；

### 4、函数嵌套/递归使用 ###

#### 1）函数嵌套使用 ####

函数中调用其他函数。  
**示例：test函数中调用test1函数**

package main
    
    import "fmt"
    
    func main() {
        
    	test(3, 6)
    }
    
    func test1(a, b int) {
        
    	fmt.Println(a + b)
    }
    func test(a int, b int) {
        
    	fmt.Println("into function test")
    	test1(a, b)
    }

##### 不定参不能直接传递给另外一个不定参 #####

![在这里插入图片描述][839307d1d92142cfbdc3665b924fb70e.png]

**解决措施：指定不定参`arr`需要传递到函数`testIndefiniteParam2`的数据个数；**

**1> 指定个数：**

package main
    
    import "fmt"
    
    func main() {
        
    
    	testIndefiniteParam(1, 2, 3, 4)
    }
    
    // 不定参不能直接传递给另外一个不定参
    func testIndefiniteParam(arr ...int) {
        
    	// 传递指定个数的数据，不报错
    	// 下标起始0，结束4（不包含4）；仅仅为索引4之前的数据
    	testIndefiniteParam2(arr[0:4]...)
    }
    func testIndefiniteParam2(arr ...int) {
        
    	fmt.Println(arr)
    }

**输出：**  
![在这里插入图片描述][c29ed28ac031468a9a9de13593baa103.png]  
**2> 若想要传递全量数据，可以用下列方式：**

testIndefiniteParam2(arr[0:]...)

#### 2）递归函数 ####

递归指函数在运行的过程中自己调用自己。

**构成递归的条件：**

1.  子问题需要与原始问题是同样的问题，且更加简单；
2.  递归需要出口，不能无限制地调用本身；在使用递归时，开发者需要设置 退出条件 ，否则递归将陷入无限循环。

**示例：斐波那契数列（fibonacci）**

package main
    
    import "fmt"
    
    func fibonacci(i int) int {
        
    	if i == 0 {
        
    		return 0
    	}
    	if i == 1 {
        
    		return 1
    	}
    	return fibonacci(i-1) + fibonacci(i-2)
    }
    
    func main() {
        
    	var i int
    	for i = 0; i < 10; i++ {
        
    		fmt.Printf("%d\n", fibonacci(i))
    	}
    }

**控制台输出：**  
![在这里插入图片描述][9bd686ea2a824d03bebe1dfc6a3f89a9.png]

### 5、匿名函数 ###

匿名函数指不需要定义函数名的一种函数实现方式，匿名函数由一个不带函数名的函数声明和函数体组成；在Go语言中，函数可以像普通变量一样被传递 & 使用，并且支持随时在代码里定义匿名函数。

构造函数时，函数没有名称；想调用函数时，需要把匿名函数赋值给一个变量，或 在构造时直接调用。

#### 1）赋值给变量 ####

func1 := func (arg1 T, arg2 T) T {
        
            ...
            return r1
    }

这里，`func1`是一个函数类型的变量，可以直接通过`func1(param1, param2)`调用函数。

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    
    	// 1> 匿名函数赋值给变量
    	func1 := func (a int, b int) int {
        
    		res := a + b
    		fmt.Printf("a + b = %d \n", res)
    		return res
    	}
    	func1(2,3)
    }

#### 2）构造时直接调用 ####

func (arg1 T, arg2 T) T {
        
            ...
            return r1
    }(param1, param2)

构造函数时，函数声明的右大括号`}`后紧跟要传递的参数(param1, param2)；这样，构造完函数后会马上调用。

**示例：**

package main
    
    import "fmt"
    
    func main() {
        
    
    	//2> 匿名函数构造时直接调用
    	func (a int, b int) int {
        
    		res := a + b
    		fmt.Printf("a + b = %d \n", res)
    		return res
    	}(2, 3)
    }

### 6、函数类型 ###

在Go语言中，函数也是一种数据类型，可以将函数赋值给一个变量，则该变量就是一个函数类型的变量了，通过该变量可以对函数调用。（匿名函数中有介绍）

所谓的声明函数类型，实际就是为已存在的函数起一个别名。尤其当我们引用二方包、三方包时，可以给别人的函数取个别名。

**语法：**

type 自定义数据类型名 func ( [parameter_list] ) [return_types]

**示例：**

package main
    
    import "fmt"
    
    // 定义函数类型 为已存在的数据类型起别名
    type funcTwoParamOneReturn func(int, int) int
    
    func main() {
        
    	// 自定义函数类型使用
    	var f funcTwoParamOneReturn
    	f = func2
    	fmt.Printf("%T", f)
    }
    
    // func(int, int)
    func func1(a int, b int) {
        
    	fmt.Println(a + b)
    }
    
    // func(int, int) int
    func func2(x int, y int) int {
        
    	fmt.Println(x + y)
    	return x + y
    }

对已有函数设置别名时，函数的参数类型/个数、返回值类型/个数 需要一一对应，否则会报错；  
![在这里插入图片描述][c7aa3f72aa404e948ff4faca078e2c8e.png]

### 7、Go内置函数 ###

和Java语言一样，在Go语言中，有一些函数无需导包即可使用，这样的内置函数有15个：

1.  make：为切片，map、通道类型分配内存并初始化对象。
2.  len：计算数组、切片、map、通道的长度。
3.  cap：计算数组、切片、通道的容量。
4.  delete：删除 map 中对应的键值对。
5.  append：将数据添加到切片的末尾。
6.  copy：将原切片的数据复制到新切片中。
7.  new：除切片、map、通道类型以外的类型分配内存并初始化对象，返回的类型为指针。
8.  complex：生成一个复数。
9.  real：获取复数的实部。
10. imag：获取复数的虚部
11. print：将信息打印到标准输出，没有换行。
12. println：将信息打印到标准输出并换行。
13. close：关闭通道。
14. panic：触发程序异常。
15. recover：捕捉 panic 的异常信息，必须卸载defer相关的代码块中。
    
     *  defer将在后面的文章中介绍

## 三、总结 ##

本文介绍了函数的一些基本概念，比如：函数是什么？为什么要使用函数？函数的特点？怎么声明一个函数？如何调用一个函数？嵌套函数是什么？匿名函数怎么声明使用？Go中内置函数有哪些？

### 对比Java来看 ###

**和Java语言一样：**

*  基础类型都是按值传递，复杂类型都是按引用传递；  
    \*Go中基础类型如需按引用传递，需要使用指针。
 *  都可以丢弃返回值。Go中使用关键字`_`接收返回值用于丢弃，Java直接不用变量接方法的返回。

**和Java语言不同的是：**

*  Go中返回值可以有多个，Java中多个值需要封装到实体或map返回；
 *  Go中的函数不支持重载，而Java方法可以重载；

**Java中的方法定义：**

访问修饰符 返回值类型 方法名(参数1类型  参数1，参数2类型 参数2...) {
        
        return 返回值;
    }

**Go中的函数定义：**

func 函数名(变量1 变量类型，变量2 变量2类型...) (返回值1 类型1，返回值2 类型2...) {
        
        return;
    }

[Link 1]: https://blog.csdn.net/Saintmm
[Spring MVC]: https://blog.csdn.net/saintmm/category_11339528.html
[SpringCloud_Ribbon_Feign]: https://blog.csdn.net/saintmm/category_11519367.html
[Nacos]: https://blog.csdn.net/saintmm/category_11579412.html
[RocketMQ]: https://blog.csdn.net/saintmm/category_11280399.html
[Spring Cloud Gateway]: https://blog.csdn.net/saintmm/category_11913259.html
[Seata]: https://blog.csdn.net/saintmm/category_11953405.html
[JUC]: https://blog.csdn.net/saintmm/category_12191195.html
[30_GO]: https://blog.csdn.net/saintmm/category_12326997.html
[26456da6bcf74d8ab70094e321fbd199.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/fa877ab9cf244be6a8ebc27d27c92000.png
[GO_Java_Golang]: https://blog.csdn.net/Saintmm/article/details/130793052
[2 Go_Hello World]: https://blog.csdn.net/Saintmm/article/details/130799639
[3 Go_API]: https://blog.csdn.net/Saintmm/article/details/130819239
[4 Go]: https://blog.csdn.net/Saintmm/article/details/130839198
[5 Go]: https://blog.csdn.net/Saintmm/article/details/130999658
[6 Go]: https://blog.csdn.net/Saintmm/article/details/131100380
[7 Go_if_switch]: https://blog.csdn.net/Saintmm/article/details/131161428
[8 Go_for range_goto_break_continue]: https://blog.csdn.net/Saintmm/article/details/131161436
[21126b58c0424aaf914ca0dd5a8708ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/00711397c3c840368b3eccb37e076a07.png
[d965aad514f84b199e60fdaaf1e13c60.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e54687a9088d402ab87d478a35bca036.png
[d0416533a9304f10a4547feab22704f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/4985e842b7c445a5ac336b9ca0fd49f0.png
[7b73c71168564f8e8843339286d0b919.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/de0b6ffe0bce46659325c49c6c39ab4f.png
[839307d1d92142cfbdc3665b924fb70e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6ce77f62ee9343db97e1cf6d843925c7.png
[c29ed28ac031468a9a9de13593baa103.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/5d5df855fd54467f80a0642a59efdcb2.png
[9bd686ea2a824d03bebe1dfc6a3f89a9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e6155c4a751b458093d8d425540facf5.png
[c7aa3f72aa404e948ff4faca078e2c8e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/3f552c2252b44e7087a9e14f6fe2cc07.png