一、函数
函数是基本的代码块，用于执行一个任务。
go语言至少有个main()函数
1）函数定义
func function_name( [parameter list] ) [return_types] {
函数体
}
func：声明这是一个函数
function_name：函数名称，函数名和参数列表一起构成了函数签名
parameter list：参数列表，注意类型在变量名之后
return_types：返回类型，不是必须的，当没有返回值时，可以不指定返回类型，也可以返回多个值，如(string,string)
函数体：函数定义的代码集合
常用函数用法：
// 函数多参无返回值 func func_name(a,b int, c string){} // 函数无参无返回值 func func_name(){} // 单个返回值 func func_name(s string) string{} // 多个返回值 func func_name (s string) (string,int){} // 命名返回参数 func func_name(s string) (result string){ ... result=1 return } // 可变参数，可变参数只能做为函数参数存在，并且是最后一个参数，本质上是slice func func_name(s string,args ...int){} // 匿名函数，调用：f(1,2) f := func(x,y int) int { return x + y }
注意：
①：Go函数不支持重载
②：一个包中不能有两个名字一样的函数
③：当两个或多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他的类型可以省略
④：函数可以返回任意数量的返回值
⑤：使用关键字 func 定义函数，左大括号依旧不能另起一行
2）函数参数
函数如果使用参数，该变量可称为函数的形参。
形参就像定义在函数体内的局部变量。
调用函数，传递过来的变量就是函数的实参，可以通过两种方式来传递参数：
| 传递类型 | 描述 |
|---|---|
| 值传递 | 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。 |
| 引用传递 | 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。 |
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数
注意：
①：无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷贝，一般来说，地址拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低
②：map、slice、chan、指针、interface默认以引用的方式传递
可变参数：
Golang 可变参数本质上就是 slice。只能有一个，且必须是最后一个。
在参数赋值时可以不用用一个一个的赋值，可以直接传递一个数组或者切片，特别注意的是在参数后加上“…”即可
任意类型的不定参数：
就是函数的参数和每个参数的类型都不是固定的
用空接口：interface{}传递任意类型数据是Go语言的惯例用法，而且interface{}是类型安全的
3）递归函数
递归，就是在运行的过程中调用自己
Go语言支持递归，注意在使用递归时，要设置退出条件，避免陷入死循环
func recursion() { recursion() /* 函数调用自身 */ } func main() { recursion() }
构成递归需具备的条件
①：子问题须与原始问题为同样的事，且更为简单
②： 不能无限制地调用本身，须有个出口，化简为非递归状况处理
4）defer
Go语言的 defer 语句会将其后面跟随的语句进行延迟处理
在 defer 归属的函数即将返回时，将延迟处理的语句按 defer 的逆序进行执行，也就是说，先被 defer 的语句最后被执行，最后被 defer 的语句，最先被执行。
关键字 defer 的用法类似于面向对象编程语言 Java 和 C# 的 finally 语句块，它一般用于释放某些已分配的资源，典型的例子就是对一个互斥解锁，或者关闭一个文件
defer关键字特性：
①：关键字 defer 用于注册延迟调用
②：这些defer调用直到所在函数 return 前才被执行。因此，可以用来做资源清理
③：多个defer语句，defer 所在的函数返回后，将按照后进先出的顺序执行 defer 保存的延迟调用函数，也就是说，后定义的defer函数先执行
④：defer 延迟调用函数可以读取并分配给返回函数的命名返回值
⑤：defer语句中的变量，在defer声明时就决定了
defer用途：
①：关闭文件句柄
②：锁资源释放
③：数据库连接释放
④：panic捕获
5）init函数和mian函数
①：init函数
go语言中init函数用于包(package)的初始化，该函数是go语言的一个重要特性
init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等
每个包可以拥有多个init函数，包的每个源文件也可以拥有多个init函数
对同一个go文件的init()调用顺序是从上到下的。
对同一个包中不同文件是按文件名字符串比较“从小到大”顺序调用各文件中的init()函数
不同包的init函数按照包导入的依赖关系决定该初始化函数的执行顺序
init函数不能被其他函数调用，而是在main函数执行之前，自动被调用
②：main函数
Go语言程序的默认入口函数（主函数）
func main(){
//函数体
}
6）函数表达式
使用函数表达式实现三目运算
// 函数表达式,实现三目运算 // 格式：func() returnType {...}() i := 1 j := 2 k := func() int { if i > j { return i } return j }() fmt.Println(k)
带参数的函数表达式：
h := func(a, b int) int { if a > b { return a } return b }(i, j)
7）匿名函数
匿名函数是指不需要定义函数名的一种函数实现方式，匿名函数由一个不带函数名的函数声明和函数体组成。
匿名函数的优越性在于可以直接使用函数内的变量，不必声明
在Go里面，函数可以像普通变量一样被传递或使用。Golang匿名函数可赋值给变量，做为结构字段，或者在 channel 里传送。
如：
getSqrt := func(a float64) float64 { return math.Sqrt(a) } fmt.Println(getSqrt(4))
上面先定义了一个名为getSqrt 的变量，初始化该变量时和之前的变量初始化有些不同，使用了func，func是定义函数的，可是这个函数和上面说的函数最大不同就是没有函数名，也就是匿名函数。这里将一个函数当做一个变量一样的操作
8）闭包
什么是闭包？闭包就是能够读取其他函数内部变量的函数。
通常只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁
Go语言支持闭包，通过匿名函数的方式，如：
// 创建函数a，返回另外一个函数。该函数的目的是在闭包中递增i的变量 func a() func() int { i := 0 b := func() int { i++ fmt.Println(i) return i } return b } func main() { c := a() c() // 1 c() // 2 c() // 3 a() //不会输出i }
9） new和make函数
在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。要分配内存，就引出来今天的new和make。 Go语言中new和make是内建的两个函数，主要用来分配内存
①：new
new函数的签名： func new(Type) *Type
Type表示参数类型，*type表示类型指针，new函数返回一个指向该类型内存地址的指针
new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。
如var a *int只是声明了一个指针变量a但是没有初始化，指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。
应该按照如下方式使用内置的new函数对a进行初始化之后就可以正常对其赋值了：
func main() { var a *int a = new(int) *a = 10 fmt.Println(*a) }
new引发panic异常：
//定义一个结构体，age字段为指针 type Student struct { age *int } //获取结构体对象指针 func getStudent() *Student { s := new(Student) // panic，因为new只会为结构体Student申请一片内存空间，不会为结构体中的指针age申请内存空间 return s }
②：make
make函数的签名：func make(t Type, size ...IntegerType) Type
make也是用于分配内存的，区别于new，它只用于slice、map以及channel的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没必要返回他们的指针了。
make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作
new函数和make函数的区别
相同点：
底层都是通过mallocgc申请内存
不同点：
①：make 返回值是”引用类型“，new 返回值是指针类型
②：make仅用于初始化 slice，map 和 chan；new 可用于初始化任意类型（new并不常用）
二、方法
Go 语言中同时有函数和方法。一个方法就是一个包含了接收者的函数。
方法可以将类型和方法封装在一起，实现强耦合。
接收者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集
Go语言中的方法时一种作用于特定类型变量的函数。这种特定类型变量叫做接收者，接收者的概念类似于Java语言中的this，和Python语言中的self。只不过Go语言中需要将this显式的声明出来。
方法的定义格式如下：
func (接收者变量 接收者类型) 方法名(参数列表) (返回类型) {
方法体
}
方法示例：
// 定义结构体 type User struct { name string gender string address string age int } // 接收User类型的方法 // 值类型的接收者 func (user User) getName() string { return user.name } // 指针类型的接收者 func (user *User) setName(name string) { user.name = name } func main() { user := &User{ name: "yangyongjie", age: 27, gender: "male", address: "nanjing", } name := user.getName() // 该方法只能User结构体类型的变量或指针才能调用 fmt.Println(name) // yangyongjie user1 := &User{} user1.setName("yyj") fmt.Println(user1.name) // yyj }
值类型的接收者和值类型的接收者方法的区别：
指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式十分接近于Java语言中的this，和Python语言中的self
当方法作用于值类型的接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但是修改操作只是针对副本，无法修改接收者变量本身。
如：
import "fmt" // 定义结构体 type User struct { name string gender string address string age int } // 值类型的接收者 func (user User) setAddress(address string) { user.address = address } // 指针类型的接收者 func (user *User) setName(name string) { user.name = name } func main() { user := &User{ name: "yangyongjie", age: 27, gender: "male", address: "nanjing", } // 接收值类型的方法，user变量本身值没有被修改 user.setAddress("beijing") fmt.Println(user.address) // nanjing // 接收指针类型的方法，user变量本身值没有被修改 user.setName("yyj") fmt.Println(user.name) // yyj }
什么时候应该使用指针类型接收者？
①：需要修改接收者中的值
②：接收者是拷贝代价比较大的大对象
③：保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者
结构体变量和结构体指针的理解：
结构体指针指向的是结构体变量的内存地址
结构体变量是结构体类型的变量本身的值
END.