标签：-bash 实参 组成 内存 now() 创建 基本使用 code 回收
高级数据类型：
高级数据类型有数组、切片、map、指针、结构体、函数、接口、通道等，本文只介绍Arrary、Slice、map、ptr。
数组：
（1）概念：
数组是同一种数据类型的集合。数组从声明时大小就已经确定，使用过程中可以修改值，但是数组的大小不可改变。
（2）初始化
方法一：使用初始化列表来设置数组元素的值
var testArray[3]int
var numArray=[3]int{4,5}
方法二：自行推断数组的长度的方式
var numArray=[...]int{4,5}
方法三：使用指定索引值的方式来初始化数组
var numArray=[...]int{1:4,3:5}
（3）数组的遍历
func main() { var a = [...]string{"南山", "罗湖", "保安"} // 方法1：for循环遍历 for i := 0; i < len(a); i++ { fmt.Println(a[i]) } // 方法2：for range遍历 for index, value := range a { fmt.Println(index, value) } }
(4)多维数组
func main() { a := [3][2]string{ {"南山", "罗湖"}, {"保安", "光明"}, {"龙华", "龙岗"}, } fmt.Println(a) fmt.Println(a[2][1]) //支持索引取值:龙岗 }
注意：多维数组只有第一层可以使用...来让编译器推导数组长度。
切片：
切片是一个拥有相同类型元素的可变长度的序列，它非常灵活，支持自动扩容。切片是一个引用类型，它的内部结构包含：地址、长度、容量。
（1）为什么用切片：
a.数组的内a容固定，不能自动扩展；
b.值传递，b数组作为函数参数时，将整个数组拷贝一份给形参；
go语言中，我们几乎可以在所有的场景中，用切片来替代数组。切片拥有自己的长度和容量，可以通过使用len()、cap()函数分别求切片的长度和容量。
（2）基于数组定义切片：
func main() { // 基于数组定义切片 a := [5]int{15, 26, 37, 48, 59} b := a[1:4] //基于数组a创建切片，包括元素a[1],a[2],a[3] fmt.Println(b) //[26 37 48] fmt.Printf("type of b:%T\n", b) //type of b:[]int c := a[1:] //[26 37 48 59] d := a[:4] //[15 26 37 48] e := a[:] //[15 26 37 48 59] }
（3）切片再切片：
func main() { //切片再切片 a := [...]string{ "南山区", "罗湖区", "光明区", "宝安区", "龙岗区", "龙华区"} fmt.Printf("a:%v type:%T len:%d cap:%d\n", a, a, len(a), cap(a)) b := a[1:3] fmt.Printf("b:%v type:%T len:%d cap:%d\n", b, b, len(b), cap(b)) c := b[1:5] fmt.Printf("c:%v type:%T len:%d cap:%d\n", c, c, len(c), cap(c)) }
（4）使用make()函数构造切片：
上面都是基于数组或切片来创建切片的，如果是动态创建一个切片，则用make([]T, size, cap)函数
（5）切片的本质：
切片的本质就是对底层数组的封装，一个slice是一个轻量级的数据结构，提供访问数组子序列（或者全部）元素的功能。一个slice由三部分组成：指针、长度（len）、容量(cap)，指针指向slice的第一个元素对应的底层数组元素的地址（并不一定是底层数组的首地址）。
（6）切片的赋值拷贝
func main() { s1 := make([]int, 3) //[0 0 0] s2 := s1 //将s1直接赋值给s2，s1和s2共用一个底层数组 s2[0] = 200 fmt.Println(s1) //[200 0 0] fmt.Println(s2) //[200 0 0] }
（7）切片的遍历
切片支持索引遍历和for range遍历
func main() { s := []int{3, 8, 9} for i := 0; i < len(s); i++ { fmt.Println(i, s[i]) } for index, value := range s { fmt.Println(index, value) } }
（8）添加元素
func main() { //append()添加元素和切片扩容 var numSlice []int for i := 0; i < 5; i++ { numSlice = append(numSlice, i) fmt.Printf("%v len:%d cap:%d ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice) } }
func main() { // copy()复制切片 a := []int{1, 2, 3, 4, 5} c := make([]int, 5, 5) copy(c, a) //使用copy()函数将切片a中的元素复制到切片c fmt.Println(a) //[1 2 3 4 5] fmt.Println(c) //[1 2 3 4 5] c[0] = 20 fmt.Println(a) //[1 2 3 4 5] fmt.Println(c) //[20 2 3 4 5] //说明copy后a和c的底层数组不是同一个数组 }
(10)从切片中删除元素
go语言中没有删除元素的方法，可以使用切片本身的特殊性来删除元素。
func main() { // 从切片中删除元素 a := []int{30, 31, 32, 33, 34, 35, 36, 37} // 要删除索引为2的元素 a = append(a[:2], a[3:]...) fmt.Println(a) //[30 31 33 34 35 36 37] }
要从切片a中删除索引为index的元素，方法是：a=append(a[:index],a[index+1:]...)
map：
（1）概念
map是一种映射关系容器，是一种无序的基于key-value的数据结构，必须初始化后才可以使用，默认初始值为nil，需要make函数来分配内存。
在map里所有的键都是唯一的，而且必须是支持==和!=操作符的类型，对于切片、函数以及包含切片的结构体等类型，由于具有引用语义，不能作为映射的键，键为这些类型编译会报错；map值可以是任意类型，所有键的类型必须相同，值也是如此。
注意：map是无序的，每次打印的顺序都可能不同。
（2）map的基本使用：
func main() { scoreMap := make(map[string]int, 8) scoreMap["张三"] = 200 scoreMap["李四"] = 100 fmt.Println(scoreMap) fmt.Println(scoreMap["李四"]) fmt.Printf("type of a:%T\n", scoreMap) } 输出： map[小明:200 李四:100] 100 type of a:map[string]int
判断某个键是否存在：value,ok:=map[key]
func main() { scoreMap := make(map[string]int) scoreMap["张三"] = 100 scoreMap["李四"] = 200 // 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值 v, ok := scoreMap["张三"] if ok { fmt.Println(v) } else { fmt.Println("没有此人") } }
map的遍历使用 for range
func main() { scoreMap := make(map[string]int) scoreMap["张三"] = 50 scoreMap["李四"] = 150 scoreMap["王五"] = 200 for k, v := range scoreMap { fmt.Println(k, v) } }
注意：遍历map时的元素顺序与添加键值对的顺序无关。
使用delete()函数删除键值对：delete(map,key)
func main(){ scoreMap := make(map[string]int) scoreMap["张三"] = 50 scoreMap["小明"] = 150 scoreMap["李四"] = 200 delete(scoreMap, "小明")//将小明:150从map中删除 for k,v := range scoreMap{ fmt.Println(k, v) } }
求map的键值对的容量，不能用cap()函数，而是用len()，map与slice一样可以自动扩容。
func main() { rand.Seed(time.Now().UnixNano()) //初始化随机数种子 var scoreMap = make(map[string]int, 5) for i := 0; i < 10; i++ { key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串 value := rand.Intn(10) //生成0~10的随机整数 scoreMap[key] = value } for k,v:=range scoreMap{ fmt.Println(k, v) } }
指针：
指针是一个代表某个内存地址值，这个内存地址往往是在内存中存储另一个变量的起始位置。go语言的指针保留的应用不到C/C++ 的1/3，不过还是保留了对基本的内存操作。学习go语言指针只需记住两个符号：&（取地址）、*（根据地址取值/解引用）。
（1）栈帧（stack）
a.用来给函数运行提供的内存空间
b.当函数调用时，产生栈帧，函数调用结束，释放栈帧
c.栈帧存储：局部变量、形参、内存字段描述
d.栈帧的空间使用完后，会自己释放
（2）空指针和野指针
空指针：未被初始化的指针
野指针：被一片无效地址空间初始化
func main() { var a *int//空指针 fmt.Println(*a) var p *int =0xc04204c080//野指针 fmt.Println(*p) }
（3）堆(heap)
make、new的变量存在堆中，堆上申请的空间在c/c++上必须释放的，而go有垃圾回收（gc）,但并不是就可以无限申请内存，因为堆的大小是有限的，所以为了能够循环地申请内存空间，在使用完后，或者不使用后，提示gc进行垃圾回收，可以通过赋nil值来提醒gc进行回收。
func new(Type) *Type，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。
func main() { a := new(int) b := new(bool) fmt.Printf("%T\n", a) // *int fmt.Printf("%T\n", b) // *bool fmt.Println(*a) // 0 fmt.Println(*b) // false }
指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。应使用内置的new函数对指针进行初始化之后就可以正常对其赋值了。
func main() { var a *int a = new(int) *a = 10 fmt.Println(*a) }
make也是用于内存分配的，区别于new，它只用于slice、map以及channel的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。
make与new的差异
a.二者都是用来分配内存
b.make只用于slice、map、channel的初始化，返回的是这三个引用类型本身
c.而new用于内存分配，初始值为类型的零值，返回的是指针
（4）变量存储
等号左边的变量，代表变量所指向的内存空间；（写）
等号右边变量，代表变量内存空间存储的数据值；（读）
func main() { var p *int p=new(int) *p=1000 fmt.Printf("%d\n",*p) fmt.Printf("%v\n",*p) }
(5)指针的函数参数
传地址（引用）:将形参的地址值作为函数参数
传值（数据）：将形参的值拷贝一份给实参
func main() { d := 99 modifty1(d) fmt.Println(d) modifty2(&d) fmt.Println(d) } func modifty1(x int) { x = 100 } func modifty2(x *int) { *x = 100 }
标签：-bash 实参 组成 内存 now() 创建 基本使用 code 回收
原文地址：https://www.cnblogs.com/juju-niuniu/p/12335481.html
