08【保姆级】-GO语言的函数、包、错误处理

之前我学过C、Java、Python语言时总结的经验：

1. 先建立整体框架，然后再去抠细节。
2. 先Know how，然后know why。
3. 先做出来，然后再去一点点研究，才会事半功倍。
4. 适当的囫囵吞枣。因为死抠某个知识点很浪费时间的。
5. 对于GO语言，切记遵守语法格式规则。（例如python语言、例如SpringBoot框架等）
   解释：某些知识点，就是很难了解，那么先做出来，然后继续向前学习，可能在某个时间点我们就会恍然大悟。

一、 函数基本介绍

1.1 基本概念

为完成某一功能的程序指令（语句）的集合，称为函数。
在Go语言中分为：自定义函数、系统函数。

func 函数名（形参列表） （返回值类型列表）{
	执行语句
	return 返回值列表
}

1. 形参列表: 表示函数的输入
2. 函数中的语句:表示为了实现某一功能代码块
3. 函数可以有返回值,也可以没有

例子： j

func main() {

	c := add(2, 5)
	fmt.Println("c=", c)

}

func add(a int, b int) int {

	c := a + b
	return c
}

1.2 包的概念

1. 在实际的开发中，我们往往需要在不同的文件中，去调用其它文件的定义的函数，比如 main.go中，去使用 utils.go 文件中的函数，如何实现? -》包
2. 现在有两个程序员共同开发一个 Go 项目,程序员 xiaoming 希望定义函数 Cal,程序员 xiaoqiang也想定义函数也叫 Cal。两个程序员为此还吵了起来,怎么办?-》包

包的本质实际上就是创建不同的文件夹，来存放程序文件。

包的基本概念： go 的每一个文件都是属于一个包的，也就是说 go 是以包的形式来管理文件和项目目录结构

• 包的三大作用

1. 区分相同名字的函数、变量等标识符
2. 当程序文件很多时,可以很好的管理项目
3. 控制函数、变量等访问范围，即作用域

• 包的基本语法

package 包名

• 引入包的基本语法

import "包的路径"

• 包使用的快速入门
  包快速入门-Go 相互调用函数，我们将func Cal 定义到文件utils.go，将utils.go放入一个包中，当其他文件需要使用utils.go的方法时，可以import该包，就可以使用了。

1.3 包使用的注意事项和细节

1. 在给一个文件打包时，该包对应一个文件夹，比如这里的utils文件夹，对应的包名是utils，文件的包名通常和文件所在的文件夹名一致，一般为小写字母。
2. 当一个文件要使用其它包函数或变量时，需要先引入对应的包。

引入方式1：import “包名”

引入方式2：
import(
	"包名"
	"包名"
)


package 指令在 文件第一行，然后是import指令
在import包时，路径从$GOPATH 的src下开始，不用带src，编译器会自动从src下开始引入。

3. 为了让其他包的文件，可以访问到本包的函数，则该函数名的首字母需要大写，类似其他语言的public，这样才能跨包访问。比如 utils.go 的

4. 在访问其他函数，变量时，其语法是 包名.函数名 ，比如这里的 main.go 文件中：

5. 如果包名较长，Go支持给包取别名，注意细节：取别名后，原来的包名就不能使用了。

说明：如果给包取了别名，则需要使用别名来访问该包的函数和变量

6. 在同一包下，不能有相同的函数名（也不能有相同的全局变量名），否则报重复定义
7. 如果你要编译成一个可执行程序文件，就需要将这个包申明为main，既 package main。 这个就是一个语法规范，如果你是写一个库，包名可以自定义。

路径下写：
- src 
 - 项目名称
   - 各个包名

1.4 函数的调用机制

关于栈区：
函数在调用的时候，基本数据类型，一般说分配到栈区，编译器存在一个逃逸分析
栈区：
add 栈区
main 栈区

1. 在调用一个函数时，会给该函数分配一个新的空间，编译器会通过自身的处理，让这个新的空间和其他的栈的空间区分开来
2. 在每个函数对应的栈中， 数据空间是独立的。不会混淆
3. 当一个函数调用完毕（执行完毕）后，程序会销毁这个函数对应的栈空间。

func main() {

	n := 10
	add(n)
	fmt.Println("main() 的n =", n)   // main() 的n = 10

}
func add(n int) {
	n = n + 1
	fmt.Println("add() 的n =", n)  // add() 的n = 11
}

1. 其中两个函数都是在栈中，当main函数只是将 n 的值 传给了add函数（值传递）.
2. 这样说来，add更改n的值，并不会更改main的n的值.
3. 其中根据栈的原则，先进后出，main先进去的，所以，先打印add函数的println语句。

关于堆区：
堆区：引用数据类型一般说分配到堆区，编译器存在一个逃逸分析

代码区：
所有的代码存储到此位置。

---

案例要求：写一个函数，传入两个int值，返回两者的相加和相减

func main() {

	n1 := 10
	n2 := 5
	add, sub := addOrSub(n1, n2)
	fmt.Println("add=", add, "sub=", sub) // add= 15 sub= 5

}
func addOrSub(n1 int, n2 int) (int, int) {
	return n1 + n2, n1 - n2
}

1.5 函数的递归调用

一个函数在函数体内 又 调用了本身，我们称为递归调用。

1. 执行一个函数时，就创建一个新的受保护的独立空间（新函数栈）
2. 函数的局部变量是独立的，不会相互影响
3. 递归必须向退出递归的条件逼近，否则就是无限递归，死鬼了
4. 当一个函数执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当函数执行完毕或者返回时，该函数本身也会被系统销毁。

递归的演示案例：

-- 第一种： 
//  第一种自己的思路(方便理解)：
// 当第1次调用test时，调用了递归，我们可以先把fmt.println打印的结果写出来，也就是3
// 当第2次调用test时，调用了递归，我们可以先把fmt.println打印的结果写出来，也就是2
// 当第3次调用test时，没有调用递归，我们可以先把fmt.println打印的结果写出来，也就是2
// 那么最后的结果，反推上去也就是：2/2/3


func main() {
	n1 := 4
	test(n1)
}
func test(n1 int) {
	if n1 > 2 {
		n1--
		test(n1)
	}
	fmt.Println("n1=", n1)
}
n1= 2
n1= 2
n1= 3


-- 第二种：
// 自己的思路：
// 不管多少次递归，那么最后结果是，最后一次不符合if条件后，才会执行的else结果。
func main() {

	n1 := 4
	test(n1)

}
func test(n1 int) {
	if n1 > 2 {
		n1--
		test(n1)
	} else {
		fmt.Println("n1=", n1)
	}
}
n1= 2

1.6 函数使用的注意事项和细节讨论

1. 函数的形参列表可以是多个，返回值列表也可以是多个。
2. 形参列表和返回值列表的数据类型可以是值类型和引用类型。
3. 函数的命名遵循标识符命名规范，首字母不能是数字，首字母大写该函数可以被本包文件和其它文件使用，类似public，首字母小写，只能被本包文件使用，其它包文件不能使用，类似private
4. 函数中的变量是局部的，函数外不生效
5. 基本数据类型和数组 默认都是值传递的，既进行值拷贝。在函数内修改，不会影响到原来的值
6. 如果希望函数内的变量能修改函数外的变量（指的是 默认以值传递的方式的数据类型），而已传入的地址&，函数内以指针的方式操作变量。

func main() {
	n1 := 4
	test(&n1)
	fmt.Println("main() n1=", n1)  //main() n1= 14
}
func test(n1 *int) {
	*n1 = *n1 + 10
	fmt.Println("test() n1=", *n1)  // test() n1= 14
}

7. Go函数不支持函数重载。
8. 在Go中，函数也是一种数据类型 ，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数 调用。

func main() {
	//在Go中，函数也是一种数据类型
	a := getSum
	fmt.Println(a(1, 2))
}

func getSum(n1 int, n2 int) int {
	return n1 + n2
}

9. 函数既然是一个种函数类型，因此在Go中，函数可以作为函数，并且调用。

1. myFun函数，将三个参数分别赋值给myFun() 其中func(int ,int)int 是一个类型。
	funvar = getSum
	num1 = 50
	num2 = 60
2. 然后将 num1 和 num2 赋值给 funvar(num1,num2）
3. 根据第一点得知，funvar 等于 getSum函数。
4. 根据getSum()函数得知，n1 + n2 =50+60. 得到结果是110。getSum()函数返回110给的是res2
5. 切记：getSum返回的110，是返回给res2的

10. 为了简化数据类型定义，Go支持自定义数据类型

基本语法：type 自定义数据类型名   数据类型 
// 理解：相当于一个别名
案例：type myInt int  
// 这时  myInt 就等价 int来使用了
// myInt 是一个类型，虽然根据定义是一个类型，是一个int类型，但是Go认为并不是同种类型。
//如代码：

案例：type mySum func(int,int)int 
// 这时 mySum就等价 一个函数类型func(int,int) int
//  创建一个mySum 类型，该类型是一个函数，名为：func(int,int)int函数

11. 支持对函数返回值命名

func main() {
	var num1 int
	var num2 int
	num1 = 10
	num2 = 10
	add, sub := addOrSub(num1, num2)
	fmt.Println("add=", add, "sub=", sub)
	// add= 20 sub= 0
}

func addOrSub(num1 int, num2 int) (add int, sub int) {
	add = num1 + num2
	sub = num1 - num2
	return
	// 此时可以忽略掉 返回类型和顺序
}

12. 只用 _ 标识符，忽略返回值
13. Go支持可变参数

// 支持0到多个参数
func sunc(args... int ) sum int {
}
// 支持1到多个参数
func sum(n1 int ,args... int) sum int{
}
14. args是slice切片（可以理解java的数组），通过args[index] key访问到各个值
15. 如果一个函数的形参列表中有可变参数，则可变参数需要放在形参列表最后。

编写函数swap(n1 *int,n2 *int) 进行交换n1 和 n2的值

func main() {
	var n1 int = 10
	var n2 int = 20
	fmt.Println("前n1=", n1, "前n2=", n2)
	swap(&n1, &n2)
	fmt.Println("后n1=", n1, "后n2=", n2)

	//前n1= 10 前n2= 20
	//后n1= 20 后n2= 10
}

func swap(a *int, b *int) {
	var test int
	test = *a
	*a = *b
	*b = test
}

1.7 init函数

每一个源文件都可以包含一个init函数，该函数会在main函数执行前，被Go运行框架调用，也就是说init会在main函数前被调用。

1. 如果一个文件同时包含全局变量定义， init函数，和main函数 ，则 执行流程：全局变量定义 -> init 函数 -> main函数

   1. 当如果有被引入的包，那么会先执行被引入的包。例如 fmt 、 utils
      

2. init函数最主要的作用，就是完成一些初始化的工作。

1.8 匿名函数

Go支持匿名函数，匿名函数就是没有名字的函数，如果我们某个函数只是希望使用一次，可以考虑使用匿名函数，匿名函数也可以实现多次调用。

1.8.1 匿名函数使用方式

在定义匿名函数时就直接调用，这种方式匿名函数只能调用一次。

// 在定义匿名函数时就直接调用，这种方式匿名函数只能调用一次。
func main() {
	resAdd := func(a int, b int) int {
		return a + b
	}(1, 2)
	fmt.Println("resAdd=", resAdd) //  resAdd= 3
}

将匿名函数赋给一个变量（函数变量），再通过该变量来调用匿名函数

resSub := func(c int, d int) int {
		return c - d
	}
	sub := resSub(1, 2)
	fmt.Println("sub=", sub) // sub= -1

1.8.2 全局匿名函数

如果将匿名函数赋给一个全局变量，那么这个匿名变量，就成为一个全局匿名函数，可以在程序有效。

var (
	myAllFunc = func(num1 int, num2 int) int {
		return num1 + num2
	}
)

// 在定义匿名函数时就直接调用，这种方式匿名函数只能调用一次。
func main() {
	fmt.Println("调用全局的匿名函数的结果为：", myAllFunc(1, 2))
	// 调用全局的匿名函数的结果为： 3
}

1.9 闭包

闭包就是一个函数和与其相关的引用环境组合的一个整体（实体）

1. AddUpper 是一个函数，返回的数据类型是fun (int) int
2. 闭包的说明
   返回的是一个匿名函数，但是这个匿名函数引用到函数外的 n,因此这个匿名函数就和n形成个整体，构成闭包。
3. 大家可以这样理解: 闭包是类，函数是操作，n 是字段。函数和它使用到 n 构成闭包。
4. 当我们反复的调用 f函数时，因为 n 是初始化一次，因此每调用一次就进行累计。
5. 我们要搞清楚闭包的关键，就是要分析出返回的函数它使用(引用)到哪些变量，因为函数和它引用到的变量共同构成闭包。

1.9.1 闭包的最佳实践

1. 编写一个函数 makeSuffix(sufix string) 可以接收一个文件后缀名(比如jpg)，并返回一个闭包2. 调用闭包，可以传入一个文件名，如果该文件名没有指定的后缀(比如.jpg),则返回 文件名jpg，如果已经有.ipg 后缀，则返回原文件名。
2. 要求使用闭包的方式完成
3. strings.HasSuffix，该函数可以判断某个字符串是否有指定的后缀。

package main

import (
	"fmt"
	"strings"
)

func main() {

	res := makeSuffix(".txt")
	fmt.Println("测试的名字是：", res("zhangsan1.txt"))
}

func makeSuffix(houzhui string) func(name string) string {
	return func(name string) string {
	    // 判断如果输入的name后缀有huizhui，那么为true。 (! 取反）
		if !strings.HasSuffix(name, houzhui) {
			return name + houzhui + "a"
		}
		return name
	}
}

1.10 函数的defer

在函数中，程序员经常需要创建资源(比如: 数据库连接、文件句柄、锁等) ，为了在函数执行完毕后，及时的释放资源，Go 的设计者提供 defer(延时机制)。

1. 当 go 执行到一个 defer 时，不会立即执行 defer 后的语句，而是将 defer 后的语句压入到一个栈中[我为了讲课方便，暂时称该栈为 defer 栈1然后继续执行函数下一个语句。
2. 当函数执行完毕后，在从 defer 中，依次从栈顶取出语句执行(注:遵守栈 先入后出的机制).
   
3. 在 defer 将语句放入到栈时，也会将相关的值拷贝同时入栈。

4. defer 最主要的价值是在，当函数执行完毕后，可以及时的释放函数创建的资源
5. 在 golang 编程中的通常做法是，创建资源后，比如(打开了文件，获取了数据库的链接，或者是锁资源，可以执行 defer file.Close() defer connect.Close()
6. 在 defer 后，可以继续使用创建资源.
7. 当函数完毕后，系统会依次从 defer 栈中，取出语句，关闭资源
8. 这种机制，非常简洁，程序员不用再为在什么时机关闭资源而烦心。

1.11 函数参数

1.11.1 两种传递方式

1. 值传递
2. 引用传递
   其实，不管是值传递还是引用传递，传递给函数的都是变量的副本，不同的是，值传递的是值的拷贝，引用传递的是地址的拷贝，一般来说，地址拷贝效率高，因为数据量小，而值拷贝决定拷贝的数据大小，数据越大，效率越低。

1.11.2 值类型和引用类型

1. 值类型:基本数据类型 int 系列,flat 系列,bool,string 、数组和结构体 struct

2. 引用类型: 指针、slice 切片、map、管道 chan、interface 等都是引用类型

3. 值类型默认是值传递:变量直接存储值，内存通常在栈中分配

4. 引用类型默认是引用传递，变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收。

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

1.12 变量的作用域

1. 函数内部声明/定义的变量叫局部变量，作用域仅限于函数内部
2. 函数外部声明/定义的变量叫全局变量，作用域在整个包都有效，如果其首字母为大写，则作用域在整个程序有效
3. 如果变量是在一个代码块，比如 for /if 中，那么这个变量的的作用域就在该代码块

1.13 字符串常用的系统函数

1. 统计字符串的长度，按字节 len(str)
   

2. 字符串遍历，同时处理有中文的问题r:=[]rune(str)
   

3. 字符串转整数: n,err := strconv.Atoi(”12"”)
   

4. 整数转字符串 str = strconv.ltoa(12345)
   

5. 字符串转[Ibyte: var bytes = []byte(“hello go”)

// 5. byte[] 转字符串
	var str string = string([]byte{97, 98, 99})
	fmt.Println("byte 转 字符串：", str) // byte 转 字符串： abc

	// 6. 字符串 转 Byte[]
	var by = []byte("abc")
	fmt.Println("字符串转byte", by) //  字符串转byte [97 98 99]

6. []byte转字符串:str=string([]byte(97,98, 99}
   

7. 10进制转 2,8,16进制: str=strconv,Formatlnt(123,2) // 2-> 8,16
   

8. 查找子串是否在指定的字符串中: strings.Contains("seafood”,“foo”) //true
   

9. 统计一个字符串有几个指定的子串 : strings.Count(“ceheese”,“e”)//4
   

10. 不区分大小写的字符串比较(==是区分字母大小写的):fmt,Println(strings.EqualFold("abc”,“Abc”) true
    

11. 返回子串在字符串第一次出现的index值，如果没有返回-1 :strings.Index(“NLT abc”,“abc”)//4
    
    

1.14 时间和日期的常用函数

package time
import "time"

time包提供了时间的显示和测量用的函数。日历的计算采用的是公历。

获取时间

// 1. 获取当前的时间
	nowTime := time.Now()
	fmt.Println(nowTime)
	//2023-11-19 17:53:20.8044591 +0800 CST m=+0.001999601

分别获取年月日

	// 2.获取年月日、时分秒
	fmt.Println("年：", nowTime.Year())       // 年： 2023
	fmt.Println("月：", int(nowTime.Month())) // 月： November
	// 强转INt类型后：月： 11
	fmt.Println("日：", nowTime.Day())    //  日： 19
	fmt.Println("时：", nowTime.Hour())   //  时： 17
	fmt.Println("分：", nowTime.Minute()) //  分： 57
	fmt.Println("秒：", nowTime.Second()) //  秒： 31

格式化时间
2006/01/02 15:04:05”这个字符串的各个数字是固定的，必须是这样写。
2006/01/02 15:04:05”这个字符串各个数字可以自由的组合，这样可以按程序需求来返回时间和日期

	//3.格式化日期时间
	fmt.Println(nowTime.Format("2006/01/02 15-04-05"))
	// 2023/11/19 18-05-25

时间的常量

	// 4. Go语言的常量。
	// 时间单位是： 秒、毫秒、微秒、纳秒
	//其中例子：1秒打印一次，以及1秒输出十次（也就是100毫秒）
	i := 1
	for ; ; i++ {
		fmt.Println(i)
		time.Sleep(time.Second) // 每次睡眠1秒
		time.Sleep(time.Millisecond*100) // 每次睡眠 100毫秒，也就是0.1秒
		if i == 5 {
			break
		}
	}

获取时间戳,和纳秒时间戳。 例如获取一个随机数（当前时间戳）

	// 5. 获取时间戳,和纳秒时间戳。 例如获取一个随机数（当前时间戳）
	fmt.Println("unix时间戳是：", nowTime.Unix(), "纳秒时间戳是：", nowTime.UnixNano())
	// unix时间戳是： 1700391072 纳秒时间戳是： 1700391072223348100
}

测试某个函数执行的时间：

1.15 内置函数

new: 用来分配内存，主要用来分配值类型，比如 int、float32,struct…返回的是指针
举例说明new的使用:

二、错误处理

2.1 异常处理

1. Go 语言追求简洁优雅，所以，Go 语言不支持传统的 try.··catch···finally 这种处理
2. Go 中引入的处理方式为: defer,panic,recover
3. 这几个异常的使用场景可以这么简单描述: Go 中可以抛出一个 panic 的异常，然后在 defer 中通过 recover 捕获这个异常，然后正常处理

defer + recover 来捕获和处理异常

func main() {

	test()
	fmt.Println("后续的代码是：--------------------")

}
func test() {
	defer func() { 
		err := recover()  // 内置函数，捕获异常
		if err != nil {   //  说明捕获结果
			fmt.Println(err)
		}
	}()
	n1 := 10
	n2 := 0
	res := n1 / n2
	fmt.Println("res=", res)
}

- 打印的结果是：
runtime error: integer divide by zero
后续的代码是：--------------------

2.2 自定义错误

Go 程序中，也支持自定义错误， 使用 errors.New 和 panic 内置函数

1. errors.New(“错误说明”)，会返回一个 error 类型的值，表示一个错误
2. panic 内置函数接收一个 interface类型的值(也就是任何值了)作为参数。可以接收 error 类型的变量，输出错误信息，并退出程序

func main() {
	test()
	fmt.Println("后续的代码....")
}

func recover2(s string) (err error) {
	if s == "test.txt" {
		return nil
	} else {
		return errors.New("读取文件错误")
	}
}

func test() {
	err := recover2("test.txt")
	if err != nil {
		panic(err)
		// 如果读取文件失败后，就会输出该错误，并且终止程序
	}
	fmt.Println("test继续执行")
}