一、指针类型
1、普通类型，变量存的就是值，也叫值类型。指针类型存的是地址
2、获取变量的地址，用&，比如：var a int， 获取a的地址 &a
3、指针类型，变量存的是一个地址，这个地址存的才是值
4、获取指针类型所指向的值，使用：* ，比如：var p *int，使用*p获取p指向的变量的值
var a int = 5
var p *int = &a 0xefefefe 指向变量a的值是 5
5、指针类型的变量初始话有两种：
5.1、直接给指针赋值其他变量的地址
func test3(){
var p *int //默认初始化nil
var a int
p = &a
*p = 200
fmt.Println(a)
}
5.2、使用new分配
func test4(){
var p *int
p = new(int)
*p = 2000
fmt.Println(*p)
}
6、练习题
6.1、练习1：写一个程序，获取一个变量的地址，并打印到终端
package main
import (
"fmt"
)
func test1(){
var a int = 5
var p *int = &a
fmt.Printf("a的地址是：%p
",p)
fmt.Printf("a的值是：%d",*p)
}
func main(){
test1()
}
运行打印的结果如下：
6.2、练习2：写一个函数，传入一个int类型的指针，并在函数中修改所指向的值
func modify(x *int){ //传入的变量x类型是指针 *int代表指针是整形的指针
*x = 200 //给x指针指向的值重新赋值为200
}
func test2(){
var a int = 5 //定义一个整形的变量a，初始值是5
var p *int = &a //定义一个指针p，指向的是a
fmt.Println("变量a的初始值是",a) //打印a的初始值
modify(p) //修改p指针指向的a的值
fmt.Println("p指针指向的a变量的改变值是",a) //打印a的值改变的结果
}
func main(){
test2()
}
执行打印的结果如下：
二、内置函数
1、close：主要用来关闭channel
2、len：用来求长度，比如string、array、slice、map、channel
3、new：用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针。示例可以看上面一的5.2，
4、make：用来分配内存，主要用来分配引用类型，比如channel、map、slice
5、append：用来追加元素到数组、slice中
6、panic和recover：用来做错误处理
7、new和make的区别
7.1、内建函数 new 用来分配内存，它的第一个参数是一个类型，不是一个值，它的返回值是一个指向新分配类型零值的指针
7.2、内建函数 make 用来为 slice，map 或 chan 类型分配内存和初始化一个对象(注意：只能用在这三种类型上)，跟 new 类似，第一个参数也是一个类型而不是一个值，跟 new 不同的是，make 返回类型的引用而不是指针，而返回值也依赖于具体传入的类型，具体说明如下：
Slice: 第二个参数 size 指定了它的长度，它的容量和长度相同。
你可以传入第三个参数来指定不同的容量值，但必须不能比长度值小。
比如 make([]int, 0, 10)
Map: 根据 size 大小来初始化分配内存，不过分配后的 map 长度为 0，如果 size 被忽略了，那么会在初始化分配内存时分配一个小尺寸的内存
Channel: 管道缓冲区依据缓冲区容量被初始化。如果容量为 0 或者忽略容量，管道是没有缓冲区的
7.3、总结：
new 的作用是初始化一个指向类型的指针(*T)，make 的作用是为 slice，map 或 chan 初始化并返回引用(T)。
三、函数
1、声明语法：func 函数名（参数列表）[（返回值列表）]｛｝
func add(){
}
func add(a int,b int){
}
func add(a int, b int) int {
}
func add(a int, b int) (int , int){
}
func add(a , b int) (int , int){
}
2、golang函数的特点：
a、不支持重载，一个包不能有两个名字一样的函数；
b、函数是一等公民，函数也是一种类型，函数也可以赋值给变量
c、匿名函数
d、多返回值
示例：
type add_func func(int, int)int
func oprator(op add_func,a int,b int)int {
//使用传进来的函数op，进行操作
return op(a,b)
}
func add(a,b int) int {
return a + b
}
func main(){
c:=add
fmt.Println(c)
sum := oprator(c,100,200)
}
3、函数参数传递方式：
3.1、值传递
3.2、引用传递
注意1：无论是值传递，还是引用传递，传递给函数的都是变量的副本。值传递是值的拷贝，一般来说地址拷贝更高效。值拷贝取决于拷贝的对象的大小，对象越大，性能越低。
注意2：map、slice、channel、指针、interface默认以引用的方式传递
func reduce(a , b int)(c int){
c = a - b
return
}
//重命名多个返回值
func calc(a,b int)(sum int,avg int){
sum = a + b
avg = sum/2
return
}
// _ 忽略返回值
func main(){
sum,_ := calc(100,200)
}
5、可变参数：
多个参数
func test11(arg...int) int{
}
一个或多个参数
func test11(a int ,arg...int) int{
}
二个或多个参数
func test11(a int,b int ,arg...int) int{
}
注意：其中arg是一个slice，我们可以通过arg[index]来获取多个参数
通过len(arg)来判断传递参数的个数
6、练习题示例
package main
import (
"fmt"
)
//练习题一：写一个函数add，支持1个或多个int相加，并返回结果
func add(a int,arg...int)int{
var sum int
//当只有一个参数时
if len(arg)==0{
sum = a
}
//当参数大于一个时
if len(arg)>0{
for i:=0;i<len(arg);i++{
//注意这里但arg里面只有一个参数时，i是等于0即arg[0]
if i == 0 {
sum = a + arg[0]
}
//当arg参数大于一个时
if i >0 {
sum+=arg[i]
}
}
}
return sum
}
//练习题二：写一个函数concat，支持1个或多个string相拼接，并返回结果
func concat(a string,arg...string)string{
var str string
if len(arg)==0{
str = a
}
if len(arg)>0{
for i:=0;i<len(arg);i++{
if i == 0 {
str = a + arg[0]
}
if i >0 {
str+=arg[i]
}
}
}
return str
}
func main(){
fmt.Println(add(-22,23,555))
fmt.Println(concat("aaa","bbbbb","ccccccc"))
}
7、defer的特点和用途
7.1、当函数返回时，执行defer语句。因此可以用来做资源清理
7.2、多个defer语句，按先进后出的方式执行
示例：
func a(){
fmt.Println("defer from a")
i:=0
defer fmt.Println(i) //defer语句中的变量，在defer声明时就决定
i++
}
func f(){
fmt.Println("defer from f")
for i:=0;i<5;i++{
defer fmt.Println(i)
}
}
func main(){
//练习三
a()
f()
}
打印的结果：
7.3、defer语句中的变量，在defer声明时就决定了
7.4、defer用途：关闭文件句柄，锁资源释放，数据库连接释放
四、递归函数
1、一个函数调用自己，就叫递归函数
2、斐波那契数
//斐波那契数列示例：
func fb( n int)int{
if n <=1{
return 1
}
return fb(n-1)+fb(n-2)
}
func main(){
for i:=0;i<10;i++{
n := fb(i)
fmt.Println(n)
}
}
3、递归的设计原则
3.1、一个大问题能够分解成相似的小问题
3.2、定义好出口条件（即结束递归循环的条件）
五、闭包
一个函数和与其相关的引用环境的组合成的实体
//示例一：
func Adder() func(int)int{
var x int
return func(delta int)int{
x +=delta
return x
}
}
//示例2：
func makeSuffixFunc(suffix string) func(string)string{
return func(name string)string{
if !strings.HasSuffix(name ,suffix){
return name + suffix
}
return name
}
}
func main(){
//练习五：闭包
//示例1：
// var f = Adder()
// fmt.Println(f(1))
// fmt.Println(f(10))
// fmt.Println(f(100))
//示例2：
func1 := makeSuffixFunc(".jpg")
func2 := makeSuffixFunc(".txt")
fmt.Println(func1(func1("test")))
fmt.Println(func2("test"))
}
六、数组和切片
1.1、排序和查找操作
排序操作主要都在sort包中，导入就可以使用
sort.Ints对整数进行排序, sort.Strings对字符串串进⾏行行排序, sort.Float64s对 浮点数进⾏行行排序.
sort.SearchInts(a []int, b int) 从数组a中查找b，前提是a 必须有序
sort.SearchFloats(a []float64, b float64) 从数组a中查找b，前提是a 必须有序
sort.SearchStrings(a []string, b string) 从数组a中查找b，前提是a 必须有序
