【Go的函数】

函数

函数的引入
函数细节祥讲
包的引入
包的细节详讲
init函数
匿名函数
闭包
defer关键字
系统函数
- 字符串相关函数
- 日期和时间相关函数
- 内置函数

函数的引入

【1】为什么要使用函数：
提高代码的复用，减少代码的冗余，代码的维护性也提高了

【2】函数的定义：
为完成某一功能的程序指令（语句）的集合，称为函数。

【3】基本语法

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

【4】函数的定义和函数的调用案例：

package main
import "fmt"

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

//自定义函数：功能：两个数相加：
func cal(num1 int,num2 int)(int){//如果返回值类型就一个的话，那么()是可以省略不写的
	var sum int = 0
	sum += num1
	sum += num2
	return sum
}
func main(){
//功能：10+20
//调用函数：
sum := cal(10,20)
fmt.Println(sum)
// var num1 int = 10
// var num2 int = 20
//求和：
// var sum int = 0
// sum += num1
// sum += num2
// fmt.Println(sum)

//功能：30+50
var num3 int = 30
var num4 int = 50
//调用函数：
sum1 := cal(num3,num4)
fmt.Println(sum1)
//求和：
// var sum1 int = 0
// sum1 += num3
// sum1 += num4
// fmt.Println(sum1)
}

函数细节祥讲

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

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

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

【4】基本语法

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

（1）函数名：
遵循标识符命名规范
首字母不能是数字
首字母大写该函数可以被本包文件和其它包文件使用（类似public)
首字母小写只能被本包文件使用，其它包文件不能使用（类似private）

（2）形参列表：
形参列表：个数：可以是一个参数，可以是n个参数，可以是0个参数
形式参数列表：作用：接收外来的数据
实际参数：实际传入的数据
在这里插入图片描述

（3）返回值类型列表：数的返回值对应的类型应该写在这个列表中

返回0个：
在这里插入图片描述
返回1个：

返回多个：
在这里插入图片描述

【5】通过例题感受内存分析：

package main
import "fmt"

//自定义函数：功能：交换两个数
func exchangeNum(num1 int,num2 int) {
	var t int
	t = numl
	numl = num2
	num2 = t
}

func main(){
	//调用函数：交换10和20
	var numl int = 10
	var num2 int = 20
	fmt.Printf("交换前的两个数:numl = %v,num2 = %v \n",numl,num2)
	exchangeNum(num1,num2)
	fmt.Printf("交换后的两个数:numl = %v,num2 = %v \n",numl,num2)
}

内存分析：
在这里插入图片描述

【6】Golang中函数不支持重载
在这里插入图片描述

【7】Golang中支持可变参数（如果你希望函数带有可变数量的参数)

package main
import "fmt"

//定义一个函数，函数的参数为：可变参数..．参数的数量可变
//args...int  可以传入任意多个数量的int类型的数据  传入0个，1个...n个
func test(args...int){
	//函数内部处理可变参数的时候，将可变参数当做切片来处理
	//遍历可变参数：
	for i := 0; i < len(args); i++ {
		fmt.Println(args[i])
	}
}

func main(){	
	test()
	fmt.Println("---------------")
    test(3)
	fmt.Println("---------------")
    test(37,58,39,59,47)
}

在这里插入图片描述

【8】基本数据类型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值。
在这里插入图片描述

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

在这里插入图片描述

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

package main
import "fmt"

//定义一个函数：
func test(num int){
	fmt.Println(num)
}

func main(){	
	//函数也是一种数据类型，可以赋值给一个变量
	a := test //变量就是一个函数类型的变量
	fmt.Printf("a的类型是:%T,test函数的类型是:%T \n",a,test)
	//a的类型是：func（int）,test函数的类型是：func（int）

	//通过该变量可以对函数调用
	a(10) //等价于test（10）
}

【11】函数既然是一种数据类型，因此在Go中，函数可以作为形参，并且调用(把函数本身当做一种数据类型）

package main
import "fmt"

//定义一个函数：
func test(num int){
	fmt.Println(num)
}

//定义一个函数，把另一个函数作为形参：
func test02 (num1 int ,num2 float32, testFunc func(int)){
	fmt.Println("-----test02")
}

func main(){	
	//函数也是一种数据类型，可以赋值给一个变量
	a := test //变量就是一个函数类型的变量
	fmt.Printf("a的类型是:%T,test函数的类型是:%T \n",a,test)
	//a的类型是：func（int）,test函数的类型是：func（int）

	//通过该变量可以对函数调用
	a(10) //等价于test（10）

	//调用test02函数：
	test02(10,3.19,test)
	test02(10,3.19,a)
}

【12】为了简化数据类型定义，Go支持自定义数据类型
基本语法：type 自定义数据类型名数据类型
可以理解为：相当于起了一个别名
例如：type mylnt int-----》这时mylnt就等价int来使用了.
在这里插入图片描述

例如：type mySum func（int,int) int-----》这时mySum就等价一个函数类型func(int,int) int
在这里插入图片描述

【13】支持对函数返回值命名

传统写法要求：返回值和返回值的类型对应，顺序不能差
在这里插入图片描述

升级写法：对函数返回值命名，里面顺序就无所谓了，顺序不用对应
在这里插入图片描述

包的引入

【1】使用包的原因：
（1）我们不可能把所有的函数放在同一个源文件中，可以分门别类的把函数放在不同的原文件中
在这里插入图片描述

（2）解决同名问题：两个人都想定义一个同名的函数，在同一个文件中是不可以定义相同名字的函数的。此时可以用包来区分

【2】案例展示包：
项目的结构：
在这里插入图片描述
代码展示：

在这里插入图片描述

包的细节详讲

1.package进行包的声明，建议：包的声明这个包和所在的文件夹同名
在这里插入图片描述

2.main包是程序的入口包，一般main函数会放在这个包下
main函数一定要放在main包下，否则不能编译执行
在这里插入图片描述

3.打包语法：
package 包名

4.引l入包的语法：import “包的路径”
包名是从$GOPATH/src/后开始计算的，使用/进行路径分隔。
在这里插入图片描述

5.如果有多个包，建议一次性导入，格式如下：
在这里插入图片描述

6.在函数调用的时候前面要定位到所在的包
在这里插入图片描述

7.函数名，变量名首字母大写，函数，变量可以被其它包访问
在这里插入图片描述

8.一个目录下不能有重复的函数
在这里插入图片描述

9.包名和文件夹的名字，可以不一样
在这里插入图片描述

10.一个目录下的同级文件归属一个包
同级别的源文件的包的声明必须一致
在这里插入图片描述

11.包到底是什么：
（1）在程序层面，所有使用相同package包名的源文件组成的代码模块
（2）在源文件层面就是一个文件夹

12.可以给包取别名，取别名后，原来的包名就不能使用了
在这里插入图片描述

init函数

【1】init函数：初始化函数，可以用来进行一些初始化的操作
每一个源文件都可以包含一个init函数，该函数会在main函数执行前，被Go运行框架调用。
在这里插入图片描述

【2】全局变量定义，init函数，main函数的执行流程？
在这里插入图片描述

【3】多个源文件都有init函数的时候，如何执行：
在这里插入图片描述

执行结果：

执行过程：

匿名函数

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

【2】匿名函数使用方式：
（1）在定义匿名函数时就直接调用，这种方式匿名函数只能调用一次（用得多）
在这里插入图片描述

（2）将匿名函数赋给一个变量（该变量就是函数变量了），再通过该变量来调用匿名函数（用得少）
在这里插入图片描述

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

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,7)
	fmt.Println(result03)
}

在这里插入图片描述

闭包

【1】什么是闭包：
闭包就是一个函数和与其相关的引用环境组合的一个整体

【2】案例展示：

package main
import "fmt"

//函数功能：求和
//函数的名字：getSum  参数为空
//getSum函数返回值为一个函数，这个函数的参数是一个int类型的参数，返回值也是int类型
func getSum() func (int) int {
	var sum int = 0
	return func (num int) int{
		sum = sum + num
		return sum
	}
}
//闭包：返回的匿名函数+匿名函数以外的变量num

func main(){
	f := getSum()
	fmt.Println(f(1))//1
	fmt.Println(f(2))//3
	fmt.Println(f(3))//6
	fmt.Println(f(4))//10
}

感受：匿名函数中引用的那个变量会一直保存在内存中，可以一直使用

【3】闭包的本质：
闭包本质依旧是一个匿名函数，只是这个函数引1入外界的变量/参数
匿名函数+引|用的变量/参数=闭包

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

【5】不使用闭包可以吗？

package main
import "fmt"

//函数功能：求和
//函数的名字：getSum  参数为空
//getSum函数返回值为一个函数，这个函数的参数是一个int类型的参数，返回值也是int类型
func getSum() func (int) int {
	var sum int = 0
	return func (num int) int{
		sum = sum + num
		return sum
	}
}
//闭包：返回的匿名函数+匿名函数以外的变量num

func main(){
	f := getSum()
	fmt.Println(f(1))//1
	fmt.Println(f(2))//3
	fmt.Println(f(3))//6
	fmt.Println(f(4))//10
	fmt.Println("-----------------")
	fmt.Println(getSum01(0,1))//1
	fmt.Println(getSum01(1,2))//3
	fmt.Println(getSum01(3,3))//6
	fmt.Println(getSum01(6,4))//10
}

func getSum01(sum int,num int) int{
	sum = sum + num
	return sum
}

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

在这里插入图片描述

defer关键字

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

【2】案例展示：
在这里插入图片描述

【3】代码变动一下，再次看结果：

在这里插入图片描述
发现：遇到defer关键字，会将后面的代码语句压入栈中，也会将相关的值同时拷贝入栈中，不会随着函数后面的变化而变化。

【4】defer应用场景：
比如你想关闭某个使用的资源，在使用的时候直接随手defer，因为defer有延迟执行机制（函数执行完毕再执行defer压入栈的语句），所以你用完随手写了关闭，比较省心，省事

系统函数

字符串相关函数

【1】统计字符串的长度，按字节进行统计：
len(str)
使用内置函数也不用导包的，直接用就行
在这里插入图片描述

【2】字符串遍历：

(1）利用方式1：for-range键值循环：
在这里插入图片描述

(2）r:=[]rune(str)
在这里插入图片描述

【3】字符串转整数：
n,err := strconv.Atoi(“666”)
【4】整数转字符串：
str = strconv.ltoa(88)
在这里插入图片描述

【5】查找子串是否在指定的字符串中：
strings.Contains(“javaandgolang”,“go")
在这里插入图片描述

【6】统计一个字符串有几个指定的子串：
strings.Count(“javaandgolang”,“a”)
在这里插入图片描述

【7】不区分大小写的字符串比较：
strings.EqualFold(“go”,“Go”)
在这里插入图片描述

【8】返回子串在字符串第一次出现的索引值，如果没有返回-1：
strings.lndex(“javaandgolang”,“a”)
在这里插入图片描述

【9】字符串的替换：
strings.Replace(“goandjavagogo”,“go",“golang”,n)
n可以指定你希望替换几个，如果n=-1表示全部替换，替换两个n就是2
在这里插入图片描述

【10】按照指定的某个字符，为分割标识，将一个字符串拆分成字符串数组：
strings.Split(“go-python-java”,“-”)
在这里插入图片描述

【11】将字符串的字母进行大小写的转换：
strings.ToLower(Go")// go
strings.ToUpper"go")//Go
在这里插入图片描述

【12】将字符串左右两边的空格去掉：
strings.TrimSpace(“ goandjava ”）
在这里插入图片描述

【13】将字符串左右两边指定的字符去掉：
strings.Trim("~golang ~”，“ ~”）
在这里插入图片描述

【14】将字符串左边指定的字符去掉：
strings.TrimLeft("~golang ~”，“ ~”）
在这里插入图片描述

【15】将字符串右边指定的字符去掉：
strings.TrimRight("~golang ~”，“ ~”）
在这里插入图片描述

【16】判断字符串是否以指定的字符串开头：
strings.HasPrefix(“http://java.sun.com/jsp/jstl/fmt”,“http”)
在这里插入图片描述

【17】判断字符串是否以指定的字符串结束：
strings.HasSuffix("demo.png”，“png”)
在这里插入图片描述

代码案例展示：

package main
import(
	"fmt"
	"strings"
)

func main(){
	//字符串的替换：
	str1 := strings.Replace("goandjavagogo","go","golang",-1)
	str2 := strings.Replace("goandjavagogo","go","golang",2)
	fmt.Println(str1)
	fmt.Println(str2)

	//按照指定的某个字符，为分割标识，将一个学符串拆分成字符串数组：
    arr := strings.Split("go-python-java","-")
	fmt.Println(arr)

	//将字符串的字母进行大小写的转换：
	fmt.Println(strings.ToLower("Go"))
	fmt.Println(strings.ToUpper("go"))

	//将字符串左右两边的空格去掉：
	fmt.Println(strings.TrimSpace("    go and java   "))

	//将字符串左右两边指定的字符去掉：
	fmt.Println(strings.Trim("~golang~","~"))

	//将字符串左边指定的字符去掉： 
    fmt.Println(strings.TrimLeft("~golang~","~"))

	//将字符串右边指定的字符去掉： 
    fmt.Println(strings.TrimRight("~golang~","~"))

	//判断字符串是否以指定的字符串开头：
	fmt.Println(strings.HasPrefix("http://java.sun.com/jsp/jstl/fmt","http"))

	//判断字符串是否以指定的字符串结束：
	fmt.Println(strings.HasSuffix("demo.png","-jpg"))
}

在这里插入图片描述

日期和时间相关函数

【1】时间和日期的函数，需要导入time包，所以你获取当前时间，就要调用函数Now函数：

package main
import (
	"fmt"
	"time"
)

func main(){
	//时间和日期的函数，需要导入time包，所以你获取当前时间，就要调用函数Now函数：
	now := time.Now()
	//Now()返回值是一个结构体，类型是：time.Time
	fmt.Printf("%v~~~对应的类型为：%T\n",now,now)
	//2021-02-0817:47:21.7600788+0800CSTm=+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())
}

【2】日期的格式化：
（1）将日期以年月日时分秒按照格式输出为字符串：

	//Printf将字符串直接输出：
	fmt.Printf("当前年月目：%d-%d-%d 时分秒: %d:%d:%d \n",now.Year(),now.Month(),
	now.Day(),now.Hour(),now.Minute(),now.Second())
	//Sprintf可以得到这个字符串，以便后续使用：
	datestr := fmt.Sprintf("当前年月日：%d-%d-%d 时分秒：%d:%d:%d\n",now.Year(),now.Month(),
	now.Day(),now.Hour(),now.Minute(),now.Second())
	fmt.Println(datestr)

(2）按照指定格式：

    //这个参数字符串的各个数字必须是固定的，必须这样写
	datestr2 := now.Format("2006/01/02 15/04/05")
    fmt.Println(datestr2)
	//选择任意的组合都是可以的，根据需求自己选择就可以（自己任意组合）。
	datestr3 := now.Format("2006 15:04")
	fmt.Println(datestr3)

在这里插入图片描述