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

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

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

先建立整体框架，然后再去抠细节。

先Know how，然后know why。

先做出来，然后再去一点点研究，才会事半功倍。

适当的囫囵吞枣。因为死抠某个知识点很浪费时间的。

对于GO语言，切记遵守语法格式规则。（例如python语言、例如SpringBoot框架等）
解释：某些知识点，就是很难了解，那么先做出来，然后继续向前学习，可能在某个时间点我们就会恍然大悟。

一、函数基本介绍

1.1 基本概念

为完成某一功能的程序指令（语句）的集合，称为函数。

在Go语言中分为：自定义函数、系统函数。

go 复制代码

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

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

例子： j

go 复制代码

func main() {

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

}

func add(a int, b int) int {

	c := a + b
	return c
}

1.2 包的概念

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

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

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

包的三大作用

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

包的基本语法

go 复制代码

package 包名

引入包的基本语法

go 复制代码

import "包的路径"

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

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

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

go 复制代码

引入方式1：import "包名"

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


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

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

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

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

go 复制代码

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

1.4 函数的调用机制

关于栈区：

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

栈区：

add 栈区

main 栈区

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

go 复制代码

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值，返回两者的相加和相减

go 复制代码

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 函数的递归调用

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

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

递归的演示案例：

go 复制代码

-- 第一种： 
//  第一种自己的思路(方便理解)：
// 当第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 函数使用的注意事项和细节讨论

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

go 复制代码

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
}

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

go 复制代码

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

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

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

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的

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

go 复制代码

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

go 复制代码

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

支持对函数返回值命名

go 复制代码

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
	// 此时可以忽略掉 返回类型和顺序
}

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

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的值

go 复制代码

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函数前被调用。

如果一个文件同时包含全局变量定义 ， init函数，和main函数 ，则执行流程：全局变量定义 -> init 函数 -> main函数
1. 当如果有被引入的包，那么会先执行被引入的包。例如 fmt 、 utils
init函数最主要的作用，就是完成一些初始化的工作。

1.8 匿名函数

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

1.8.1 匿名函数使用方式

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

go 复制代码

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

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

go 复制代码

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

1.8.2 全局匿名函数

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

go 复制代码

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，该函数可以判断某个字符串是否有指定的后缀。

go 复制代码

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

当 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来回收。
如果希望函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量。从效果上看类似引用。

1.12 变量的作用域

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

1.13 字符串常用的系统函数

统计字符串的长度，按字节 len(str)
字符串遍历，同时处理有中文的问题r:=[]rune(str)
字符串转整数: n,err := strconv.Atoi("12"")
整数转字符串 str = strconv.ltoa(12345)
字符串转[Ibyte: var bytes = []byte("hello go")
[]byte转字符串:str=string([]byte(97,98, 99}
10进制转 2,8,16进制: str=strconv,Formatlnt(123,2) // 2-> 8,16
查找子串是否在指定的字符串中: strings.Contains("seafood","foo") //true
统计一个字符串有几个指定的子串 : strings.Count("ceheese","e")//4
不区分大小写的字符串比较(==是区分字母大小写的):fmt,Println(strings.EqualFold("abc","Abc") true
返回子串在字符串第一次出现的index值，如果没有返回-1 :strings.Index("NLT abc","abc")//4

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

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 内置函数

二、错误处理

一、函数基本介绍