1 指针

指针是一种数据类型，相当于用一个变量 去存储一个数据地址，这个变量叫做指针变量，

1.1 & 取地址

// 定义一个指针变量   定义一个
格式: var 变量名 *数据类型 = 数值
&变量   取这个变量的地址var num = 100
var p *int = &num // &num 取出num的地址 赋值给 p这个指针
fmt.Println("p 之歌指针存储的是 变量num的地址", p)

1.2 * 取值

// *指针变量 表示取一个指针变量对应地址的值var num_value = *p
fmt.Println("指针变量p存储地址下的数值：", num_value)p 之歌指针存储的是 变量num的地址 0xc00001c0a8
指针变量p存储地址下的数值： 100

2 函数

函数：固定执行写功能的一个代码块

// 格式:  main就是一个函数
func 函数名(参数名 类型,.....)(返回值类型...){函数体return 返回值
}
// 函数调用
接收函数返回值,_,.. := 函数名(实参，...)

2.1 函数的参数

2.1.1 实参

调用函数时，传入函数内部的参数

接收函数返回值,_,.. := 函数名(实参，...)  //这一部分参数

2.1.2 形参

接收到外部参入的，卸载函数的参数列表中的参数变量

func 函数名(参数名 类型,.....)  // 这一部分参数

2.2 返回值

函数返回值分两部分
1 返回值类型

(返回值类型...)

2 返回值变量

return 返回值，...

3 接收返回值

接收函数返回值,_,.. := 函数名(实参，...) 

2.3 函数变量

函数作为一种数据类型，他也能当作一个变量进行定义

// 可以通过变量接收f := func() {fmt.Println("这是一个你们那个函数，使用变量进行接收")}
// 调用这个函数 只用函数变量() 形式调用f()

2.4 匿名函数

没有名字的函数，不给函数设置名字

// 匿名函数  没有名字的函数  去掉函数名func() {fmt.Println("sajksdj")}() // 在函数的末尾直接加上() 就变成了立即调用函数，定义了就执行

2.5 高阶函数

函数既然是一个数据结构，那他也可以当作参数
高阶函数就是接收一个函数作为参数的 函数

package mainimport "fmt"
// 高阶函数
//
// 参数是一个函数
//
// 返回值也是一个函数
func leaveHigh(f1 func()) func() {f1() // 只要调用就是执行f := func() {fmt.Println("这是一个高阶函数")}return f
}
func main() {f1 := func() {fmt.Println("这是一个当作参数的函数")}res_f := leaveHigh(f1)// 调用这个函数res_f()
}

2.6 闭包

闭包是一个特殊的匿名函数，这个匿名函数，使用外部函数的变量和资源，就叫一个完整的环境叫闭包

func bibao(num int) {func() {// 函数内部使用外部数据或变量fmt.Println("num is：", num)}()
}// 装饰器函数
/*1 接收一个函数作为参数2 返回一个函数3 内部函数医用外部函数的，变量或参数
*/
func outerFunc(f func()) func() {count := 0innerFunc := func() {f()     // 使用外部函数的参数count++ // 使用外部函数的 变量fmt.Println("这是装饰的内容==========", count)}return innerFunc
}

3 defer 和 init函数

3.1 defer

defer表示这，延迟调用，被defer修饰的的代码，会在整个函数返回前调用，

package mainimport "fmt"func foo() {fmt.Println("defer1111之前")defer fmt.Println("延时1111111")foo1()fmt.Println("defer1111之后")}
func foo1() {fmt.Println("defer22222之前")defer fmt.Println("延时222222")fmt.Println("defer22222之后")
}
func deFunc() int {count := 100defer func() {count = 1}()return count
}
func main() {// defer 语句   注册延迟调用// 被defer 修饰的语句最后调用/*执行时间：同结构的代码执行return之前执行，在执行,同一结构的被defer修饰的，按顺序执行return 分为两部操作rval = 值retdefer 语句在return中执行顺序是rval = 值defer 内容ret所以，def依然能够修改返回出去的值 ps*/foo()fmt.Println(deFunc())}

init 函数

4 数组

go语言中的数组时一组相同数据的集合，存储的时同一类的数据

• 数字的数据默认值由数据类型决定
• 空数组 为 []

4.1 一维数组

4.1.1 数组定义

• 初始化数组的时候就需要定义数组的长度，数组的长度时固定的

// 定义数组的格式
var 数组名 [数组长度]数组类型
||
数组名:=[数组长度]数字类型{数据元素}
||
// make函数创建数组
数组名 :=make([]数组类型,容量)
||
// 通过指定下边数据来给数组赋值
var 数组名 =[...]数据类型{0:1,3:4}
arr4 := [...]int{0: 1, 3: 9}
fmt.Println(arr4)// 声明并赋值数组 
// [...]  表示不定长数组 由后面的{} 元素个数推断数组数据的个数
var 数组名 =[...]数组类型{数组元素,...}var arr = [...]int{1, 2, 3, 2, 3}
fmt.Println(arr)var arr1 [3]int
arr1[1] = 1
arr1[2] = 2
arr1[0] = 2
fmt.Println(arr1)
// 简短定义
arr2 := [3]int{1, 2, 3}
fmt.Println(arr2)
// make 函数定义
arr3 :=make([]int,2)arr3 := make([]int, 2)
arr3[0] = 999
arr2[1] = 100
fmt.Println(arr3)

4.1.2 数组的索引和添加、修改

数组的索引时由0开始

// 使用数组索引查看数据
// 格式： 数组名[索引]
fmt.Println(arr1[1])// 修改 数组名[下标]=值   赋值也是相同

4.1.3 数组的遍历

• 按照下标循环遍历

arr4 := [...]int{0: 1, 3: 9}
for i := 0; i < 4; i++ {fmt.Println(arr4[i])
}

• 使用 range 遍历数据

// 相当于的带数组的每一个元素 赋值给data
for data := range arr4 {fmt.Println(data)
}

4.2 二维数组

4.2.1 数组的定义

// 格式:
var 数组名 =[行数][列数]数据类型{数据,...}varr := [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println(varr)

4.2.2 数组的遍历

varr := [2][3]int{{1, 2, 3}, {4, 5, 6}}fmt.Println(varr)for i, v := range varr {for _, v2 := range varr[i] {fmt.Println(v, "  =  ", v2)}}

5 切片 重点

package mainimport ("fmt"
)func main() {// 切片：是一个动态的数组，能够进行动态的扩展// 语法: var 变量 []类型// 		变量 := []类型{数据值}var age = []int{1, 2, 3, 4}fmt.Println(age)age1 := []int{1, 2, 3, 4}fmt.Println(age1)// make函数，创建一个数据类型(常用)    声明数组并开辟空间// 语法：make(数据类型,长度,容量)name := make([]string, 2, 3)fmt.Println(len(name), cap(name))fmt.Println(name)// 切片操作// append() 向后追加数据一个数据// 语法：接收返回变量 := append(要追加的切片,追加数据)name[0] = "zhang"name[1] = "feng"name = append(name, "liu")fmt.Println(name)name = append(name, "li")fmt.Println(len(name), cap(name)) // 4 6   追加时，容量不够，容量自动扩大为原来的二倍   3-->6// 添加// 追加一个切片   变量名后面加  ...name1 := []string{"My", "His"}name = append(name, name1...)fmt.Println(name)fmt.Println(len(name), cap(name))// 插入// 像头部插入一个数据或一个切片numData := []int{1, 2, 3, 4}// 头部插入一个数据numData = append([]int{-2, -1, 0}, numData...) // 将0当成切片，再将 numData切片天添加到这个切片后面 实现头部插入fmt.Println(numData)// 指定的任意位置插入一个切片或一个数据/*思路:将指定索引位置的数据拆成两份，一份startNum，一份endNum，进行两次拼接gNum = gNum+endNumgNum = startNum+gNum只能先拼接后面的，再拼接前面的*/gNum := []int{9, 9, 9, 9}index := 2startNum, endNum := numData[:index], numData[index:]gNum = append(gNum, endNum...)gNum = append(startNum, gNum...)fmt.Println(gNum)// 删除  指定位置的数据needNum := []int{1, 2, 3, 4, 5, 6}index = 2getStartNum, getEndNum := needNum[:index], needNum[index+1:]var a []inta = append(getStartNum, getEndNum...)fmt.Println(a)
}

6 map

7 结构体