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

一、函数基本介绍
- 1.1 基本概念
- 1.2 包的概念
- 1.3 包使用的注意事项和细节
- 1.4 函数的调用机制
- 1.5 函数的递归调用
- 1.6 函数使用的注意事项和细节讨论
- 1.7 init函数
- 1.8 匿名函数
- - 1.8.1 匿名函数使用方式
  - 1.8.2 全局匿名函数
- 1.9 闭包
- - 1.9.1 闭包的最佳实践
- 1.10 函数的defer
- 1.11 函数参数
- - 1.11.1 两种传递方式
  - 1.11.2 值类型和引用类型
- 1.12 变量的作用域
- 1.13 字符串常用的系统函数
- 1.14 时间和日期的常用函数
- 1.15 内置函数
二、错误处理

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

先建立整体框架，然后再去抠细节。
先Know how，然后know why。
先做出来，然后再去一点点研究，才会事半功倍。
适当的囫囵吞枣。因为死抠某个知识点很浪费时间的。
对于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 + breturn c
}

1.2 包的概念

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

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

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

包的三大作用

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

包的基本语法

package 包名

引入包的基本语法

import "包的路径"

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

在这里插入图片描述

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

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

引入方式1：import “包名”引入方式2：
import("包名""包名"
)package 指令在 文件第一行，然后是import指令
在import包时，路径从$GOPATH 的src下开始，不用带src，编译器会自动从src下开始引入。

为了让其他包的文件，可以访问到本包的函数，则该函数名的首字母需要大写，类似其他语言的public，这样才能跨包访问。比如 utils.go 的
在访问其他函数，变量时，其语法是 包名.函数名 ，比如这里的 main.go 文件中：
如果包名较长，Go支持给包取别名，注意细节：取别名后，原来的包名就不能使用了。

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

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

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

1.4 函数的调用机制

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

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

func main() {n := 10add(n)fmt.Println("main() 的n =", n)   // main() 的n = 10}
func add(n int) {n = n + 1fmt.Println("add() 的n =", n)  // add() 的n = 11
}1. 其中两个函数都是在栈中，当main函数只是将 n 的值 传给了add函数（值传递）.
2. 这样说来，add更改n的值，并不会更改main的n的值.
3. 其中根据栈的原则，先进后出，main先进去的，所以，先打印add函数的println语句。

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

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

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

func main() {n1 := 10n2 := 5add, 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 函数的递归调用

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

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

递归的演示案例：

-- 第一种： 
//  第一种自己的思路(方便理解)：
// 当第1次调用test时，调用了递归，我们可以先把fmt.println打印的结果写出来，也就是3
// 当第2次调用test时，调用了递归，我们可以先把fmt.println打印的结果写出来，也就是2
// 当第3次调用test时，没有调用递归，我们可以先把fmt.println打印的结果写出来，也就是2
// 那么最后的结果，反推上去也就是：2/2/3func main() {n1 := 4test(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 := 4test(n1)}
func test(n1 int) {if n1 > 2 {n1--test(n1)} else {fmt.Println("n1=", n1)}
}
n1= 2

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

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

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

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

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

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

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

在这里插入图片描述

为了简化数据类型定义，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函数

在这里插入图片描述

支持对函数返回值命名

func main() {var num1 intvar num2 intnum1 = 10num2 = 10add, 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 + num2sub = num1 - num2return// 此时可以忽略掉 返回类型和顺序
}

只用 _ 标识符，忽略返回值
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 = 10var n2 int = 20fmt.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 inttest = *a*a = *b*b = test
}

1.7 init函数

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

在这里插入图片描述

如果一个文件同时包含全局变量定义， init函数，和main函数 ，则执行流程：全局变量定义 -> init 函数 -> main函数
1. 当如果有被引入的包，那么会先执行被引入的包。例如 fmt 、 utils
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 闭包

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

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

1.9.1 闭包的最佳实践

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

package mainimport ("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(延时机制)。

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

在这里插入图片描述

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

1.11 函数参数

1.11.1 两种传递方式

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

1.11.2 值类型和引用类型

值类型:基本数据类型 int 系列,flat 系列,bool,string 、数组和结构体 struct
引用类型: 指针、slice 切片、map、管道 chan、interface 等都是引用类型
值类型默认是值传递:变量直接存储值，内存通常在栈中分配
引用类型默认是引用传递，变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收。
如果希望函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量。从效果上看类似引用。