Golang--函数、包、defer、系统函数、内置函数

1、何为函数

函数作用：提高代码的复用型，减少代码的冗余，提高代码的维护性

函数定义：为完成某一功能的程序指令(语句)的集合,称为函数。

语法：

func 函数名(形参列表)(返回值类型列表){

//执行语句

//......

return 返回值列表

}

例子：

Go 复制代码

package main
import "fmt"

func dp(a int)(int){
	if a == 1{
		return 1
	}
	return a + dp(a-1)
}

func main(){
	fmt.Println(dp(10))
}

2、详讲函数

对特定的功能进行提取，形成一个代码片段，这个代码片段就是我们所说的函数

函数的作用：提高代码的复用性

函数和函数是并列的关系，所以我们定义的函数不能写到main函数中

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

2.1 函数名

遵循标识符命名规范:见名知意 addNum,驼峰命名addNum
首字母不能是数字
首字母大写 该函数可以被本包文件和其它包文件使用(类似public)
首学母小写 只能被本包文件使用 ，其它包文件不能使用(类似private)

2.2 形参列表

形参列表：个数->0~n个参数
形式参数列表：作用->接收外来的数据
实际参数：实际传入的数据

2.3 返回值类型列表

函数的返回值对应的类型应该写在这个列表中，如果没有返回值，返回值类型什么都不写就可以了
返回值个数：0~n个
返回值有多个时，如果有返回值不想接收，那么可以利用_进行忽略

2.4 函数栈帧

Go 复制代码

package main
import "fmt"
//自定义函数：功能：交换两个数
func exchangeNum (num1 int,num2 int){ 
        var t int
        t = num1
        num1 = num2
        num2 = t
}
func main(){	
        //调用函数：交换10和20
        var num1 int = 10
        var num2 int = 20
        fmt.Printf("交换前的两个数： num1 = %v,num2 = %v \n",num1,num2)
        exchangeNum(num1,num2)
        fmt.Printf("交换后的两个数： num1 = %v,num2 = %v \n",num1,num2)
}

查看实参和形参的地址：

2.5 Golang不支持函数重载

2.6 Golang中支持可变参数

定义一个函数，函数的参数为：可变参数 ... 参数的数量可变

args...int 可以传入任意多个数量的int类型的数据传入0~n个

函数内部处理可变参数的时候，将可变参数当做切片来处理
Go 复制代码
package main
import "fmt"

//可变参数函数
func sum(nums...int){
	total := 0
	for _,num := range nums{
		total += num
	}
	fmt.Println(total)
}

Go 不允许将多个不同类型的可变参数组合在函数参数列表中，
  //也就是说，在一个函数内部，你不能将可变参数列表分为不同的类型。
// func print(nums...int,str...string){
// 	fmt.Println(nums)
// 	fmt.Println(str)
// }

func main(){
	sum(1,2)
	sum(1,2,3)
	nums := []int{1,2,3,4}
	sum(nums...)

	//print(1,2,3,"hello","golang")
}

2.7 值传递和引用传递

值传递：基本数据类型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值。
Go 复制代码
package main
import "fmt"

func printArr(arr []int){
	for _, val := range arr{
		val += 10
		fmt.Println(val)
	}
}

func main(){
	//定义一个数组
	arr := [10]int{1,2,3,4,5,6,7,8,9,0}
	//将数组传递给函数
	printArr(arr[:]) //[11 12 13 14 15 16 17 18 19 10]
	//查看数组
	fmt.Println(arr) //[1 2 3 4 5 6 7 8 9 0]
}

引用传递：如果希望在函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量。从效果来看类似引用传递。
Go 复制代码
package main
import "fmt"

func printArr(arr *[]int){
	//遍历数组
	for i := 0; i < len(*arr); i++ {
		(*arr)[i] += 10
	}
	fmt.Println(*arr)
}

func main(){
	//定义一个数组
	arr := []int{1,2,3,4,5,6,7,8,9,0}
	//将数组的地址传递给函数
	printArr(&arr) //[11 12 13 14 15 16 17 18 19 10]
	//查看数组
	fmt.Println(arr) //[11 12 13 14 15 16 17 18 19 10]
}

2.8 函数类型

在Go中，函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用。
函数既然是一种数据类型，因此在Go中，函数可以作为形参，并且调用（把函数本身当做一种数据类型）（回调函数）

Go 复制代码

package main
import "fmt"

func printArr(arr *[]int){
	//遍历数组
	for i := 0; i < len(*arr); i++ {
		(*arr)[i] += 10
	}
	fmt.Println(*arr)
}

func main(){
	//函数也是一种数据类型，可以赋值给一个变量
	a := printArr //函数类型的变量
	//查看函数类型
	fmt.Printf("a的类型：%T\n，printArr函数的类型：%T\n",a, printArr) //a的类型：func(*[]int)

	//定义一个数组
	arr := []int{1,2,3,4,5,6,7,8,9,0}
	//通过变量调用函数
	a(&arr) //[11 12 13 14 15 16 17 18 19 10]
}

Go 复制代码

package main
import "fmt"

func printArr(arr *[]int){
	//遍历数组
	for i := 0; i < len(*arr); i++ {
		(*arr)[i] += 10
	}
	fmt.Println(*arr)
}

func printArr_String(printArrFunc func(*[]int),arr *[]int, str *string)(bool){
	printArrFunc(arr)
	fmt.Println(*str)
	return true
}

func main(){
	//函数也是一种数据类型，可以赋值给一个变量
	a := printArr //函数类型的变量
	//查看函数类型
	fmt.Printf("a的类型：%T\nprintArr函数的类型：%T\n",a, printArr) //a的类型：func(*[]int)
	fmt.Printf("printArr_String函数的类型：%T\n",printArr_String) //printArr_String函数的类型：func(func(*[]int), *[]int, *string) bool

	//定义一个数组
	arr := []int{1,2,3,4,5,6,7,8,9,0}
	//通过变量调用函数
	a(&arr) //[11 12 13 14 15 16 17 18 19 10]
	//定义一个字符串
	str := "hello golang"
	//通过变量调用函数
	printArr_String(a,&arr,&str) //[11 12 13 14 15 16 17 18 19 10] hello golang
}

2.9 type 自定义数据类型名

基本语法:type 自定义数据类型名数据类型

可以理解为 : 相当于起了一个别名

Go 复制代码

package main
import "fmt"

type myInt int
type myAdd func(a,b myInt)myInt

func add(a,b myInt)myInt{
	return a + b
}

func main(){
	var a myAdd
	a = add
	fmt.Println(a(1,2))
}

2.10 支持对函数返回值命名

传统写法要求：返回值和返回值的类型对应，顺序不能差

升级写法：对函数返回值命名，里面顺序就无所谓了，顺序不用对应

Go 复制代码

package main
import "fmt"

//传统函数返回值写法
func f()(int, string){
	nun := 1
	str := "hello golang"
	//返回值和返回值类型需要一致，顺序需要一致
	return nun,str
}

//函数返回值命名写法
func f1()(num int,str string){
	num = 1
	str = "hello golang"
	//返回值和返回值类型需要一致，顺序可以不一致
	return 
}

func main(){
	//传统函数返回值写法
	nun,str := f()
	fmt.Println(nun,str) //1 hello golang

	//函数返回值命名写法
	num,str := f1()
	fmt.Println(num,str) //1 hello golang
}

2.11 Golang没有宏

在 Go 语言中，并没有像 C 或 C++ 那样的 #define 预处理器指令来定义宏。取而代之的是，Go 使用常量和变量来实现类似的功能。
可以使用const关键字来定义变量来实现类似的宏变量，但这并不等同于宏。常量在编译时就确定了值，而不能像宏那样具有更复杂的文本替换。
没有宏函数，只能通过定义普通函数来调用
Go 语言设计的初衷是提倡清晰和简洁，使用函数来代替宏提供了更高的类型安全性和可读性。

Go 复制代码

package main  

import "fmt"  

const Pi = 3.14  

func main() {  
    fmt.Println("Pi:", Pi)  
}

Go 复制代码

package main  

import "fmt"  

const (  
    ServerAddress = "localhost:8080"  
    MaxRetries    = 5  
)  

func main() {  
    fmt.Println("Server Address:", ServerAddress)  
    fmt.Println("Max Retries:", MaxRetries)  
}

Go 还允许使用 iota 定义一组相关的常量，自动递增。

Go 复制代码

package main  

import "fmt"  

const (  
    Sunday = iota  
    Monday  
    Tuesday  
    Wednesday  
    Thursday  
    Friday  
    Saturday  
)  

func main() {  
    fmt.Println("Sunday:", Sunday)  //0
    fmt.Println("Monday:", Monday)  //1
    fmt.Println("Tuesday:", Tuesday)  //2
}

3、包

3.1 包的引用

使用包的原因：

我们不可能把所有的函数放在同一个源文件中，可以分门别类的把函数放在不同的源文件中
解决同名问题：两个人都想定义一个同名的函数 ，在同一个文件中是不可以定义相同名字的函数的。此时可以用包来区分。

示例：

注意：

如果变量名、函数名、常量名首字母大写，则可以被其他的包访问;

如果首字母小写，则只能在本包中使用（利用首字母大写小写完成权限控制）

import导入语句通常放在文件开头包声明语句的下面。

导入的包名需要使用双引号包裹起来。

根据Go语言的规范，包的导入路径应该是从$GOPATH/src开始的相对路径或者是绝对路径

在函数调用时前面要定位到所在的包

建议包的声明这个包和所在的文件夹同名

main包时程序的入口包，一般main函数会放在这个包下

需要配置一个环境变量：GOPATH

注意：最新版本需要禁止GO111MODULE，否则无法使用GOPATH实现下述操作。

禁止/启用GO111MODULE：

禁止（Windows）：set GO111MODULE=off，请注意，这个设置只在当前cmd会话中有效。

启用（Windows）：set GO111MODULE=on

禁止（PowerShell）：$env:GO111MODULE = "off"，请注意，这个设置只在当前PowerShell会话中有效。

启用（PowerShell）：$env:GO111MODULE = "on'"

3.2 包的使用

package 包名， 进行包的声明（建议：包的声明和目录同名）
main包是程序的入口包，一般main函数会放在这个包下，main函数一定要放在main包下，否则不能编译执行
引入包的语法：import "包的路径"，包名是从**$GOPATH/src/**后开始计算的（使用GOPATH，需要配置环境变量），使用/进行路径分隔
如果有多个包，建议一次性导入，如：
import(
//"包名"
//"包名"
)
在函数调用的时候前面要定位到所在的包
函数名，变量名首字母大写，函数，变量可以被其它包访问
一个目录下不能有重复的函数（归属于同一个包）
包名和文件夹的名字，可以不一样
一个目录下的同级文件归属一个包 ，同级别的源文件的包的声明必须一致
可以给包取别名，取别名后，原来的包名就不能使用了

包是什么：

在程序层面，所有使用相同 package 包名的源文件组成的代码模块
在源文件层面就是一个文件夹

4、init函数

init函数：初始化函数，可以用来进行一些初始化的操作
每一个源文件都可以包含一个init函数 ，该函数会在main函数执行前，被Go运行框架调用。

执行流程：
全局变量定义 > init函数 > main函数

多个源文件 都有init函数的时候，如何执行：

5、匿名函数

Go支持匿名函数，如果我们某个函数只是希望使用一次，可以考虑使用匿名函数
匿名函数使用方式：

在定义匿名函数时就直接调用 ，这种方式匿名函数只能调用一次（用的多）
将匿名函数赋给一个变量(该变量就是函数变量了)，再通过该变量来调用匿名函数（用的少）

如何让一个匿名函数，可以在整个程序中有效呢?将匿名函数给一个全局变量就可以了

Go 复制代码

package main
import "fmt"
var Func01 = func (num1 int,num2 int) int{
        return num1 * num2
}
func main(){
        //定义匿名函数：定义的同时调用
        result := func (num1 int,num2 int) int{
                return num1 + num2
        }(10,20)
        fmt.Println(result)
        //将匿名函数赋给一个变量，这个变量实际就是函数类型的变量
        //sub等价于匿名函数
        sub := func (num1 int,num2 int) int{
                return num1 - num2
        }
        //直接调用sub就是调用这个匿名函数了
        result01 := sub(30,70)
        fmt.Println(result01)
        result02 := sub(30,70)
        fmt.Println(result02)
        result03 := Func01(3,4)
        fmt.Println(result03)
}

6、闭包

闭包：闭包就是一个函数 和与其相关的引用环境组合 的一个整体
闭包形式：返回的匿名函数+匿名函数以外的变量（ 匿名函数+引用的变量/参数 = 闭包**）**
匿名函数中引用的那个变量会一直保存在内存中，可以一直使用

Go 复制代码

package main
import "fmt"

func getSum() func (int) int{
	sum := 0
	return func (num int) int{
		sum += num
		return sum
	}
}

func main(){
	f := getSum()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60
}

闭包的本质：闭包本质依旧是一个匿名函数，只是这个函数引入外界的变量/参数

闭包的特点：

返回的是一个匿名函数，但是这个匿名函数引用到函数外的变量/参数 ,因此这个匿名函数就和变量/参数形成一个整体，构成闭包。
闭包中使用的变量/参数会一直保存在内存中，所以会一直使用，意味着闭包不可滥用（对内存消耗大）

使用场景：

不使用闭包的时候：想保留的值，不可以反复使用
闭包应用场景：闭包可以保留上次引用的某个值，我们传入一次就可以反复使用了

7、defer关键字

在函数中，程序员经常需要创建资源，为了在函数执行完毕后，及时的释放资源，Go的设计者提供defer关键字。

在Go中，程序遇到defer关键字，并不会立即执行defer后的语句，而是将defer后的语句压入一个栈中（栈：先进后出），然后继续执行函数后面的语句
在函数执行完毕后，从栈中取出语句开始执行 ，按照先进后出的规则执行语句
遇到defer关键字，会将后面的代码语句压入栈中，也会将相关的值同时拷贝入栈中，不会随着函数后面的变化而变化

defer应用场景：

比如你想关闭某个使用的资源，在使用的时候直接随手defer ，因为defer有延迟执行机制（函数执行完毕再执行defer压入栈的语句），在函数执行完后自动开始调用

8、系统函数

8.1 字符串相关函数

统计字符串的长度,按字节进行统计：
函数：len(str)，内置函数不需要导包，直接使用
Go 复制代码
package main
import "fmt"

func main(){
	str := "hello golang"
	fmt.Println(len(str)) //12
}

字符串遍历：

1、使用for-range遍历

2、使用配合len进行下标线性访问
Go 复制代码
package main
import "fmt"

func main(){
	str := "hello golang"

	//遍历字符串
	//for-range
	for _,ch := range str{
		fmt.Printf("%c",ch)
	}
	fmt.Println()
	//len
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c",str[i])
	}
}

字符串转整数：

函数：n, err := strconv.Atoi("str")

Go 复制代码

package main
import(
	"fmt"
	"strconv"
)

func main(){
	str1 := "1232"
	str2 := "02"

	num1,_ := strconv.Atoi(str1)
	num2,_ := strconv.Atoi(str2)

	fmt.Println(num1 + num2) //1234
}

整数转字符串：
函数：str = strconv.Itoa(num)
查找子串是否在指定的字符串中:

函数：bool = strings.Contains(原串, 子串)
Go 复制代码
package main
import(
	"fmt"
	"strings"
)

func main(){
	str1 := "hello golang"
	str2 := "godd"

	fmt.Println(strings.Contains(str1,str2)) //false
}

统计一个字符串有几个指定的子串:
函数：count = strings.Count(原串,子串)
Go 复制代码
package main
import(
	"fmt"
	"strings"
)

func main(){
	str1 := "gogogogog"
	str2 := "go"

	fmt.Println(strings.Count(str1,str2)) //4
}

不区分大小写 的字符串比较:
函数：bool = strings.EqualFold(str1 , str2)

区分大小写 的字符串比较：

使用 == 比较运算符
返回子串在字符串第一次出现的索引值，如果没有返回-1 :

函数：index = strings.lndex("javaandgolang" , "a")
字符串的替换：

函数：str = strings.Replace(原串, 替换目标串, 替换串, n)

n可以指定你希望替换几个, 如果n=-1表示全部替换，替换两个n就是2
按照指定的某个字符，为分割标识，将一个学符串拆分成字符串数组:
函数：arrStr = strings.Split("go-python-java", "-")
将字符串的字母进行大小写的转换:

函数：

str = strings.ToLower("Go") // go

str = strings.ToUpper"go") //Go
将字符串左右两边的空格去掉:

函数：str = strings.TrimSpace(" go and java ")
将字符串左右两边指定的字符去掉:
函数：str = strings.Trim("~golang~ ", " ~")
将字符串左边指定的字符去掉:

函数：str = strings.TrimLeft("~golang~", "~")
将字符串右边指定的字符去掉:
函数：str = strings.TrimRight("~golang~", "~")
判断字符串是否以指定的字符串开头:
函数：bool = strings.HasPrefix("hello golang", "hello")
判断字符串是否以指定的字符串结束:

函数：bool = strings.HasSuffix("main.go", ".go")

8.2 日期和时间相关函数

时间和日期的函数，需要到入time包，获取当前时间，就要调用Now函数：

Go 复制代码

package main
import (
        "fmt"
        "time"
)
func main(){
        //时间和日期的函数，需要到入time包，所以你获取当前时间，就要调用函数Now函数：
        now := time.Now()
        //Now()返回值是一个结构体，类型是：time.Time
        fmt.Printf("%v ~~~ 对应的类型为：%T\n",now,now)
        //2021-02-08 17:47:21.7600788 +0800 CST m=+0.005983901 ~~~ 对应的类型为：time.Time
        //调用结构体中的方法：
        fmt.Printf("年：%v \n",now.Year())
        fmt.Printf("月：%v \n",now.Month())//月：February
        fmt.Printf("月：%v \n",int(now.Month()))//月：2
        fmt.Printf("日：%v \n",now.Day())
        fmt.Printf("时：%v \n",now.Hour())
        fmt.Printf("分：%v \n",now.Minute())
        fmt.Printf("秒：%v \n",now.Second())
}

按照指定格式：

9、内置函数

内置函数/内建函数：Golang设计者为了编程方便，提供了一些函数，这些函数不用导包可以直接使用，我们称为Go的内置函数/内建函数

内置函数存放位置：在builtin包下，使用内置函数直接用就行

常见内置函数：

len函数：

统计字符串的长度,按字节进行统计

new函数：

分配内存，主要用来分配值类型（int系列、float系列、bool、string、数组和结构体struct）

make函数：

分配内存，主要用来分配引用类型（指针、slice切片、map、管道chan、interface 等）

其他内置函数可以看：Go语言标准库文档中文版 | Go语言中文网 | Golang中文社区 | Golang中国