跳转控制语句和函数

跳转控制语句

break

结束当前循环语句。用于终止某个语句块的执行，中断当前for循环或跳出switch语句。
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层的语句块。

若没有打标签，break会默认跳出最近的循环。

continue

跳出本次循环进入下一次循环。
continue语句出现在多层嵌套的语句块中时，可以通过标签指明要跳过的是哪一层的语句块。

continue可以简化代码

改写前：

for{
   if(num==0){
       break
   }
   if(num>0){
       a++
   }
   if(num<0){
   b++
   }

改写后：

for{
   if(num==0){
       break
   }
   if(num>0){
   //满足该情况时，直接跳出本次循环
   //下面就不用再继续判断了
       a++
       continue
   }
   b++;
}

goto

return

函数

概念：为完成某一功能的程序指令（语句）的集合，称为函数。在go中，函数分为自定义函数、系统函数。
函数名的第一个字母大写，则为全局函数，调用包时就可以调用该函数。
函数的定义：

package main
import (
	"fmt"
)
func cal(n1 float64,n2 float64) float64{
//括号里的是形参，外面那个float64是返回值数据类型
	return n1+n2
}
func main(){
	var n1,n2 float64
	fmt.Scanln(&n1,&n2)
	n3:=cal(n1,n2)
	fmt.Println(n3)
}

包的引用和使用原理
专门用于定义函数，让其他文件来调用，因为不可能把所有函数都写在main.go里面。

包的本质实际上就是创建不同的文件夹，来存放程序文件。
go的每一个文件都是属于一个包的，也就是说go是以包的形式来管理文件和项目目录结构的。






包的注意点和细节说明

调用其他包函数的时候：包名.函数名
调用其他包变量的时候：包名.变量名
这里函数名的首字母记得要大写。
当包名太长时，可以对其重命名使用，但是原来的包名就不能使用了。方法：在包的路径前面加上重命名的包名。
例：

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

golang中函数调用的机制的底层分析：


当函数需要返回多个值时：


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

基本数据类型和数组默认都是值传递，即进行值拷贝。在函数内修改，不会影响到原来的值。（注意此处与c++不同，c++中数组一般都是引用，会改变实参）
如果希望函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量，从效果上看类似引用。

package main

import(
	"fmt"
	_"go_code/chap01/fundemo01/utils"
)
func get(n *int)  {
	*n=*n+1
}
func main()  {
	var n int
	fmt.Scanln(&n)
	get(&n)
	fmt.Println(n)
}

go函数不支持重载。
什么是重载？
函数名相同，形参个数或者类型不同

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

package main

import(
	"fmt"
	_"go_code/chap01/fundemo01/utils"
)
func get(n *int)  {
	*n=*n+1
}
func main()  {
	a:=get
	fmt.Printf("a的类型是%T,get类型是%T",a,get)
}

输出结果：

还可以这样调用函数：

res:=a(&n)//等价 res:=get(&n)

函数既然是一种数据类型，那么函数可以作为形参并且调用。

上图有一处错误，myfun函数还需要补上返回值类型。

自定义数据类型

注意

支持对函数返回值命名

func cal(n1 int,n2 int) (sum int,sub int){
     sum=n1+n2
     sub=n1-n2
     return
     //这样写默认return sum,sub
     //顺序也不会乱掉

这里的切片可以看作动态数组来理解。
如果要使用可变参数（切片），则需要将其放在形参列表的最后位置。

package main

import(
	"fmt"
	_"go_code/chap01/fundemo01/utils"
)
func get(n int,arr... int) int {
	for i:=0;i<len(arr);i++ {
		n+=arr[i]
	}
	return n
}
func main()  {
	var n int
	fmt.Scanln(&n)
	fmt.Println(get(n,1,2))
}

init函数

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

==面试题：==如果main.go和utils.go中都含有变量定义，init函数时，执行流程是怎样的呢？
顺序如图：

如果utils.go又引入了别的文件呢？
那么同理，就像main.go引入了utils.go一样

匿名函数

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

闭包

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


总而言之，return上面的那些变量只会初始化一次，黑色框框里的内容形成闭包。
闭包的最佳实践

package main

import(
	"fmt"
	"strings"
	_"go_code/chap01/fundemo01/utils"
)
func makeSuffix(suffix string) func (string) string {
//该函数内下面代码和suffix形成闭包
	return func (name string) string {
		if !strings.HasSuffix(name,suffix){
			return name+suffix
		}
		return name
	}
}
func main()  {
	f2:=makeSuffix(".jpg")
	fmt.Println("文件名处理后：",f2("winter"))//winter.jpg
	fmt.Println("文件名处理后：",f2("bird.jpg"))//bird.jpg
}

函数中–defer

输出结果顺序如图中注解所标注的数字。

defer的细节说明：

注意：虽然defer在函数结束后执行，但是值一旦拷贝进去后，函数内后面对值的修改不会影响到defer中的数值。

defer最主要的价值是在，当函数执行完毕后，可以及时地释放函数创建的资源。

模拟代码：

函数参数的传递方式

变量的作用域

注意：赋值语句不能在函数体外

字符串中常用的系统函数

字符串函数详解p133-135

时间和日期相关函数

需要导入time包
获取当前时间：

package main

import(
	"fmt"
	"time"
	_"strings"
	_"go_code/chap01/fundemo01/utils"
)
func main()  {
	now:=time.Now()
	fmt.Printf("now=%v now type=%T",now,now)
	//输出结果：
//now=2022-02-16 23:20:00.9318011 +0800 CST m=+0.001352101 now type=time.Time
}

如何获取更多时间信息？

输出结果：

如果想要将May改为数字5，只需要强转int（）为int就行了。

格式化日期时间：


也可以用字符串接收：

p137-138

内置函数

new 的运用

输出结果：

图解：
num2是指针类型，它的值是它指向的一块地址，地址指向的值默认值是0，0的地址是上面那个东西。

如果我想要更改num2指向的值的大小，则：*num2=100 即可

make
用来分配内存，主要用来分配引用类型，比如channel、map、slice。（后面再补充）

go错误处理机制

使用defer+recover来捕获和处理异常
不仅能报错，还能让程序继续执行

go自定义错误


注意：图中所说的终止程序是指终止整个程序而不是终止该函数。