DAY 99 go03

1 函数 
    -func 函数名(参数 类型,参数 类型)(返回值类型){}
    
2 参数可以是函数类型，返回值是函数类型
    -函数的参数和返回值都是类型的一部分
3 闭包函数---》go中函数是一等公民，头等函数
4 类名重命名
5 if   else if else
6 循环：for 
7 switch

 

1 数组

package main
​
import "fmt"
​
// 数组：数组是同一类型元素的集合。例如，整数集合 5,8,9,79,76 形成一个数组。连续存储
//Go 语言中不允许混合不同类型的元素，例如包含字符串和整数的数组
​
func main() {
​
    // 1 定义数组
    //var a [4]int
    //fmt.Println(a)
​
    //2 定义并初始化
    //var a [3]int=[3]int{3,3}
    //var a =[3]int{3,3,3}
    //a :=[30]int{3,3,3,3,4,54,}
    //fmt.Println(a)
​
    //3 定义，使用
    //var a [3]string
    //var a [3]bool
    //a[0]=true  // 根据索引取值，从0开始，没有负数
    ////a[-1]=true // 错误
    ////a[3]=true  //不能超过索引范围
    //fmt.Println(a)
    //b :=a[2]
    //fmt.Println(a[2])
    //fmt.Println(b)
​
    //4 数组是值类型（当做参数传递，在函数中修改，会不会影响原来的数组：不会）
    // 值类型，当做参数传递，是copy一份，传递过去
    //var a =[3]int{3,3,3}
    //test(a)
    //fmt.Println("原来的",a)
​
    // 5 数组长度(数组的长度在定义阶段就固定了，以后不能改)
    //var a =[3]int{3,3,3}
    //fmt.Println(len(a))  // 内置函数len
​
​
    // 6 循环数组(两种方式)
    //var a =[3]int{3,3,3}
    // 按索引取
    //for i:=0;i<len(a);i++  {
    //  fmt.Println(a[i])
    //}
​
​
    // 按迭代取值  rang是关键字，后面放可迭代的值，会返回两个值，第一个值是索引，第二个值是值
    //如果只用一个值接收，就是索引
    //for i,v:=range a{
    //for _,v:=range a{
    //  //fmt.Println("索引是：",i)
    //  fmt.Println("z值：",v)
    //}
​
​
    // 多维数组
    //var a [3][3]int  //定义
    //
    //fmt.Println(a)
    ////b:=a[0]
    ////var b [3]int=a[0]
    //fmt.Println(a[0])
    //a[1][2]=99
    //fmt.Println(a)
    //
    ////多维数组的循环
    //for _,v:=range a{
    //  for _,v1:=range v{
    //      fmt.Println(v1)
    //  }
    //}
​
    // 多维数组定义并初始化
    //var a [3][3]int=[3][3]int{{1,1},{2,3,4},{6,6,6}}
    //fmt.Println(a)
​
    // 数组定义并初始化
    //var a [3]int=[3]int{0,0,99}
    //指定某个位置初始化
    //var a [300]int=[300]int{299:99,88:1001}
    //fmt.Println(a)
}
func test(a [3]int)  {
    a[0]=999
    fmt.Println(a)
}

 

2 切片

package main
​
import "fmt"
​
// 切片（用的非常广泛，类比python中的列表，类比java中的list：arrylist，linkedlist）
​
//切片是由数组建立的一种方便、灵活且功能强大的包装,【切片本身不拥有任何数据。它们只是对现有数组的引用】
​
func main() {
    //1 定义切片
    //定义数组
    //var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
    ////定义切片(中括号中不写东西，表示切片类型，写了东西表示数组类型)
    //var s []int=a[:]
    ////var s =a[0:10]  //从数组的第0个位置切到最后，做成s切片
    ////s :=a[0:10]  //从数组的第0个位置切到最后，做成s切片
    ////fmt.Printf("%T",s)
    //fmt.Println(s)
    //s[0]=999
    //fmt.Println(s)
    ////a变成了什么样子:切片的更改会影响底层数组，数组的更改会影响切片
    //fmt.Println(a)
    //a[9]=888
    //fmt.Println(a)
    //fmt.Println(s)
​
    // 2 从数组中切出切片
    //var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
    //var s []int=a[5:]  //从第5个位置切到最后
    //
    //s[0]=999
    //fmt.Println(s)
    //fmt.Println(a)
    //a[7]=777
    //fmt.Println(s)
    //fmt.Println(a)
​
    //3 从数组中切出切片
    //var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
    //var s []int=a[5:8]  //从第5个位置切到8，前闭后开，[6,7,8]
    ////fmt.Println(s)
    //a[8]=999
    //fmt.Println(s)
    //fmt.Println(a)
​
    //4 切片的追加值
    //var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
    //var s []int=a[5:8]  //从第5个位置切到8，前闭后开，[6,7,8]
    //fmt.Println(s)
    //a[8]=999
    ////使用内置函数append
    ////s=append(s,777)
    ////s=append(s,888)
    //fmt.Println(s)
    //fmt.Println(a)
​
    //5 切片底层存储
    //{point:指向数组的指针，length：3，可用数组的长度（容量）：5}
    //6 切片的长度和容量
    //fmt.Println("长度是：",len(s))
    //fmt.Println("容量：",cap(s))  //内置函数cap
​
    //6 如果追加到最大容量会？
    //var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
    //var s []int=a[5:8]  //从第5个位置切到8，前闭后开，[6,7,8]
    //s=append(s,88)
    //s=append(s,99)
    //fmt.Println("长度是：",len(s))
    //fmt.Println("容量：",cap(s))  //内置函数cap
    //fmt.Println("数组是：",a)
    //fmt.Println("切片是",s)
    //
    ////超过最大容量
    //s=append(s,666)
    //fmt.Println("长度是：",len(s)) //6
    //fmt.Println("容量：",cap(s))  //10  如果超过最大容量，会重新申请一个底层数组（大小是原来切片容量的两倍），把值copy进去，跟原来指向的数组无关了
//fmt.Println("数组是：",a)    //1 2 3 4 5 6 7 8 88 99
//fmt.Println("切片是",s)//6 7 8 88 99 666
//
//// 跟原来数组无关了
//s[0]=111
//fmt.Println("数组是：",a)    //1 2 3 4 5 6 7 8 88 99
//fmt.Println("切片是",s)//6 7 8 88 99 666
//
////7 切片的修改，按照索引修改
//s[6]=99999  //报错，修改只能改长度内的，跟容量无关，如果超了长度，报错
​
//8 通过make来创建切片
//指定类型，指定长度，指定容量（容量可以不写，容量就是长度）
//var a []int= make([]int,3,5)
//var a []int= make([]int,3)
//fmt.Println(len(a))
//fmt.Println(cap(a))
//a=append(a,6)
//fmt.Println(len(a))
//fmt.Println(cap(a))
//a=append(a,7)
//a=append(a,8)
//a=append(a,9)
//fmt.Println(len(a))
//fmt.Println(cap(a))
​
// 9 初始化的三种方式
//var a []int= make([]int,3)  //对切片进行初始化
//var a []int //切片类型的零值  nil,是指针类型的0值
//if a==nil{
//fmt.Println("wos k")
//}
//fmt.Println(a)
//var a []int=[]int{1,2,3,4,4}  //对切片进行初始化
//fmt.Println(a)
//fmt.Println(len(a))
//fmt.Println(cap(a))
​
//10 切片参数传递：切片是引用类型，传到函数中，修改会影响原来的
//var a []int=[]int{1,2,3,4,4}
//fmt.Println(len(a))
//fmt.Println(cap(a))
//test2(a) // copy传递
//
//fmt.Println("切片的值为：",a)
​
//11 多维切片
//var a [][]int=make([][]int,3,5)
//
////fmt.Println(a[1])
////print(a[1][1]) //在这报错
//a[1]=make([]int,3,3)
//print(a[1][1])
​
//var a [][]int=[][]int{{1,2,3,4},{1,2},{6,6,6,6}}
//fmt.Println(a[2])
//fmt.Println(len(a[1]))
//fmt.Println(cap(a[1]))
////循环切片
//for _,v:=range a{
//for _,v1:=range v{
//fmt.Println(v1)
//  }
//}
//var a []func()=make([]func(),3,3)
//a[0]= func() {
//fmt.Println("xxxx")
//}
//a[1]= func() {
//
//}
​
​
//12 内存优化（copy）
//var a [1000]int
//b:=a[0:3]  //[0,0,0]
//b[0]=999
//b[2]=888 //[999,0,888]
//
////var dst=make([]int,2,3)
//var dst=make([]int,6,6)
//fmt.Println(dst)
//copy(dst,b)
//fmt.Println(dst)  //[999,0]
​
​
}
func test2(a []int)  {
a[0]=999
a=append(a,888) // 如果在函数中追加正巧超过切片的容量，再改值，跟原来就没关系了
​
fmt.Println(a)
​
}

 

 

4 maps

package main
​
import "fmt"
​
//maps:类似于字典，   key：valu存储方式
​
func main() {
    // 1 定义map，key值必须可hash，用的最多就是数字和字符串
    //var a map[int]string
    //fmt.Println(a)
    //if a==nil{
    //  fmt.Println("我是空的")
    //}
    ////2 赋值，取值
    //a[1]="lqz" // 没有初始化，报错
​
    // 3 初始化   使用make初始化map时，不需要传数字
    //var a map[int]string=make(map[int]string)
    //fmt.Println(a)
    ////赋值
    //a[1]="lqz"
    //a[99]="egon"
    //
    //fmt.Println(a)
    //fmt.Println(a[1])
​
    //4 取不存在的值,得到value值的空值
    //var a map[int]string=make(map[int]string)
    //a[1]="lqz"
    //fmt.Println(a[99])  //空，value值的空
​
    //var a map[int]int=make(map[int]int)
    //fmt.Println(a[9])  // value值的空值，0
    //var a map[int][]int=make( map[int][]int)
    //fmt.Println(a[1])  //value值的空值 []-->nil
    //if a[1]==nil{
    //  fmt.Println("是nil")
    //}
​
​
    //var a map[int]int=make(map[int]int)
    ////var res int=a[0]
    //a[0]=999
    //v,ok :=a[0]   //如果能取到，v就是value值，ok是true     如果娶不到v是value的空值，ok是false
    //fmt.Println(v)
    //fmt.Println(ok)
​
​
    //5 删除map中的元素
    //var a map[int]string= map[int]string{1:"egon",4:"lqz",7:"zs"}
    //fmt.Println(a)
    //fmt.Println(a[4])
    //delete(a,5)  //如果存在就删除，不存在就不操作，不报错
    //delete(a,4)
    //fmt.Println(a)
​
    //6 获取map长度
    //var a map[int]string= map[int]string{1:"egon",4:"lqz",7:"zs"}
    //fmt.Println(len(a))
    //a[9]="ssss"
    //fmt.Println(len(a))
    ////map有没有容量？看不到容量----》hash类型的底层存储--》基于数组存储
    ////fmt.Println(cap(a))
​
    // 7 map是引用类型,当参数传递，影响原来的
    //var a map[int]string= map[int]string{1:"egon",4:"lqz",7:"zs"}
    //test5(a)
    //fmt.Println(a)
​
    // 8 map的相等性，只能跟nil比较
    //if a ==nil{
    //  fmt.Println("为空")
    //}else {
    //  fmt.Println("不为空")
    //}
    //var b map[int]string= map[int]string{1:"egon",4:"lqz",7:"zs"}
    //if a==b{  //不能这么比较
    //
    //}
​
    //9 类型
    //var a []map[int]int=make([]map[int]int,3)
//var b map[string][]int
//var c map[string]map[int]int
​
​
​
​
//10 数组的大小是类型的一部分
//var a [3]map[int]int
//var b [4]int
//if a==b{}
​
​
​
​
​
​
}
func test5(a map[int]string)  {
a[1]="利用衣服"
fmt.Println(a)
​
}