GO语言三

1 switch

package main

// 多条件匹配，用于替换多个if else

func main() {
	//1 switch基本使用
	//var a=10
	//switch a {
	//case 8:
	//	fmt.Println("8")
	//case 9:
	//	fmt.Println("9")
	//case 10:
	//	fmt.Println("10")
	//}

	//2 默认情况（Default Case）

	//var a=8
	//switch a {
	//case 8:
	//	fmt.Println("8")
	//case 9:
	//	fmt.Println("9")
	//case 10:
	//	fmt.Println("10")
	//default: //上面所有条件都不符合，执行我
	//	fmt.Println("我不知道")
	//}

	//3多表达式判断
	//var a=66
	//switch a {
	//case 7,8,9:
	//	fmt.Println("8")
	//case 10,11,12:
	//	fmt.Println("9")
	//case 13,14,15,16,17:
	//	fmt.Println("10")
	//default: //上面所有条件都不符合，执行我
	//	fmt.Println("我不知道")
	//}

	//4 无表达式
	// and 和 or    ----》 &&   ||
	//var a = 10
	//switch {
	//case a == 8:
	//	fmt.Println("8")
	//case a == 9:
	//	fmt.Println("9")
	//case a == 10 || a==11:
	//	fmt.Println("10")
	//default: //上面所有条件都不符合，执行我
	//	fmt.Println("我不知道")
	//}
	//5 Fallthrough
	//var a = 8
	//switch {
	//case a == 8:
	//	fmt.Println("8")
	//	fallthrough   //无条件执行下一个case中的代码
	//case a == 9:
	//	fmt.Println("9")
	//	fallthrough
	//case a == 10 :
	//	fmt.Println("10")
	//default: //上面所有条件都不符合，执行我
	//	fmt.Println("我不知道")
	//}
}

2 数组

package main

import "fmt"

//数组：数组是同一类型元素的集合，类似于python中的列表（列表可以放任意元素）

//python中列表，为什么能放任意类型的元素？
//	-python中一切皆对象，对象是一个引用（内存地址）
func main() {
	//1 数组的声明(数组有大小，放的数据类型),定义阶段长度固定了，以后不能改
	//定义了一个长度为3的int类型数组
	// int 默认值 是0
	// string 默认值是 ""
	// bool 类型默认值  false
	// 数组的默认值   跟它的数据是有关系的，数组存放类型的空值
	//var a [4]int
	//var a [5]string
	//fmt.Println(a)

	//1.1 定义并初始化
	//var a [3]int =[3]int{1,2,3}
	//var a =[3]int {1,2,3}
	// a:=[3]int{1,2,3}
	//var a [3]int=[3]int{1,2,3,4}  //错误
	//只想把第29个位置置为1 ，其它都是0
	//var a [30]int=[30]int{28:1,23:999}
	// 了解 (这不是可变长)
	//a :=[...]int{28:1,23:999}  //长度定下了29
	//a :=[...]int{2,3,4}  //长度定下了3
	//a :=[3]int{2,3,4}  //长度定下了3
	//1.2 使用
	//fmt.Println(a[2])
	//fmt.Println(a)
	//fmt.Println(a[3])   // 不能超长


	//2 数组是值类型（值类型,引用类型），当做函数传参，传到函数内部，修改数组，不会影响原来的
	// go中函数传参，都是copy传递

	// python中 可变类型和不可变类型（一切皆对象，都是引用）
	//python强行把 数字，字符串，元组做成不可变数据类型
	//1 数字，字符串，元组做成不可变数据类型，当做参数传参，在函数中修改不可变数据类型，不会改变原来的
	//2 其他的，在函数中修改，都会影响原来的
	// python是值传递还是引用传递？
	/*
	Python参数传递统一使用的是引用传递方式。
		因为Python对象分为可变对象(list,dict,set等)和不可变对象(number,string,tuple等)，
		当传递的参数是可变对象的引用时，因为可变对象的值可以修改，
		因此可以通过修改参数值而修改原对象
		当传递的参数是不可变对象的引用时，虽然传递的是引用，参数变量和原变量都指向同一内存地址，
		但是不可变对象无法修改，所以参数的重新赋值不会影响原对象，
	 */
	//var a =[30000]int{2,4,6}
	////var b =[3]int{2,4,6}
	//fmt.Println(a)
	//test(a)
	//fmt.Println(a)

	//3 数组的长度  len()
	//var a =[30000]int{2,4,6}
	//fmt.Println(len(a))

	//4 循环数组（使用 range 迭代数组）
	//第一种方式
	//var a =[3]int{2,4,6}
	//for i:=0;i<len(a);i++{
	//	fmt.Println(a[i])
	//}
	//第二种通过range, range不是一个内置函数，它是一个关键字
	//i:=range a   i是索引 ，一个值来接收，就是索引
	//i,v:=range a  i是索引，v是具体的值，如果两个值来接收，就是索引和值
	//var a =[3]int{2,4,6}
	//for i:=range a{
	//	fmt.Println(i)
	//}
	//var a =[3]int{2,4,6}
	////for i,v:=range a{
	////	fmt.Println(i)
	////	fmt.Println(v)
	////}
	//for _,v:=range a{
	//	fmt.Println(v)
	//}
	//5 多维数组（数组套数组）

	//var a [3][3]int
	//定义并初始化
	//var a [3][3]int=[3][3]int{{1,2,3},{4,5,6},{7,8}}
	////使用
	//a[0][1]=999
	//fmt.Println(a)
	//var a [3][3][3]int
	//fmt.Println(a)


}

func test(x [30000]int)  {
	x[0]=999
	fmt.Println(x)

}



//数组大小是类型的一部分
	var a [3]int 
	var b [4]int
	b=a
	test4(b)


func test4(a [3]int)  {
	fmt.Println(a)
}

3 切片

package main

import "fmt"

//切片：切片是由数组建立的一种方便、灵活且功能强大的包装，
//   切片本身不拥有任何数据。它们只是对现有数组的引用
func main() {
	//1 创建一个切片
	//先创建一个 数组
	//var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
	//创建切片(基于上面的数组切出来，从第0个位置切到最后一个位置)
	//var b =a[:]
	//var b =a[5:]   //第5个位置切到最后
	//var b =a[5:9]  ////第5个位置切到第9个位置,前闭后开区间

	//中括号有东西，就是数组，没有东西就是切片
	//var b[]int =a[5:9]
	//fmt.Println(b)

	//2 切片的修改（切片的修改会影响原来的数组，数组的修改也会影响切片）
	//var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
	//var b[]int =a[5:9]
	//切片修改影响数组
	//b[0]=999
	//数组修改，影响切片
	//a[6]=888
	//fmt.Println(b)
	//fmt.Println(a)

	//3 切片的长度和容量
	//len() :长度，现在有多少值
	//cap() :容量,总共能放多少值
	//var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
	////var b[]int =a[5:9]
	////var b[]int =a[0:3]
	//var b[]int =a[2:3]
	//fmt.Println(len(b))
	//fmt.Println(cap(b))

	//4 使用 make 创建一个切片
	//切片空值是？nil类型（引用类型空值都是nil）
	//var a []int
	//fmt.Println(a)
	//if a==nil{
	//	fmt.Println("我是空的")
	//}
	//a[0]=100  //这样写，你觉得可以么？直接报错
	//fmt.Println(a)
	//make内置函数。第一个参数写类型，第二个参数是切片的长度，第三个参数是切片的容量
	//var a []int=make([]int,3,4)
	//var a []int=make([]int,3)   //长度是多少3，容量是3，容量如果不传，默认跟长度一样
	////a[0]=999
	////a[9]=100  //你觉得行么？不行！！！
	//a[2]=999    //中括号取，只能取到长度
	////a[3]=888   //报错！！！！
	//fmt.Println(a)
	//fmt.Println(len(a))
	//fmt.Println(cap(a))

	//切片如果基于数组切出来
	//var a [10]int=[10]int{1,2,3,4,5,6,7,8,9,10}
	//var b[]int =a[5:9]
	//b=append(b,777)
	//b=append(b,666)  //现在就不会依赖原来的数组了，现在再改变，不会影响原来的数组了
	//
	//b[0]=11111
	//fmt.Println(b)
	//fmt.Println(len(b))
	//fmt.Println(cap(b))
	//fmt.Println(a)

	//5 追加切片元素
	//var a []int=make([]int,4,5)
	////在最后追加一个元素 999
	//a=append(a,999)
	////会怎么样？不会报错，
	////追加的时候，一旦超过容量，会重写创建一个数组，让切片指向新的数组，新数组大小是原来切片容量的两倍
	//a=append(a,888)
	//a=append(a,888)
	//a=append(a,888)
	//a=append(a,888)
	//a=append(a,888)
	//
	//a=append(a,888)
	//fmt.Println(a)
	//fmt.Println(len(a))
	//fmt.Println(cap(a))
	//6 切片的函数传递(引用类型，传递，修改原来的)
	//var a []int=make([]int,4,5)
	//fmt.Println(a)
	//test2(a)    //copy传递
	//fmt.Println(a)

	//切片的内部结构
	//a=
	//{
	//	指针：0x111
	//	len:4
	//	cap:5
	//}

	//7 多维切片
	//var a []int=[]int{1,2,3,4,5}  //类似于数组初始化，切片初始化
	//fmt.Println(a)
	//fmt.Println(len(a))
	//fmt.Println(cap(a))


	//var a [][]int=make([][]int,3,4)
	//
	//var a [][]int=make([][]int,3,4)
	//这个值是什么？
	//fmt.Println(a[0])
	//a[0][1]=100
	//if a[0]==nil{
	//	fmt.Println("xxxx")
	//}


	//var a [][]int=[][]int{{1,2,3},{2,3},{4,5,5,6,7,8,9}}
	////fmt.Println(a)
	////fmt.Println(len(a[2]))
	////fmt.Println(cap(a[2]))
	//a[0][1]=999
	//fmt.Println(a)
	//8  切片copy
	//var a []int=make([]int,6,7)
	//var b []int =[]int{1,2,3,4,5}
	//fmt.Println(a)
	//fmt.Println(b)
	////把b的数据copy到a上
	//copy(a,b)
	//fmt.Println(a)
	//fmt.Println(b)
	//循环切片
	var b []int =[]int{1,2,3,4,5}
	for _,v:=range b{
		fmt.Println(v)
	}




}
func test2(a []int)  {
	a[0]=999
	a=append(a,888)
	fmt.Println(a)
	fmt.Println(cap(a))
}

4 maps

package main

import "fmt"

//maps--->hash --->字典
// key:value---->key必须可hash

// map 在定义时，key（数字和字符串）和value的类型固定了

func main() {
	//1 如何创建 map
	//map的类型  ：map[key的类型]value的类型
	//var a map[int]string
	// map的空值是什么？ nil  （引用类型的空值都是nil）
	//fmt.Println(a)
	//if a==nil{
	//	fmt.Println("我是空的")
	//}

	//定义并初始化(make完成)
	//var a map[int]string=make(map[int]string)
	//fmt.Println(a)
	//if a==nil{
	//	fmt.Println("我是空")
	//}
	//定义并初始化，直接赋值var a map[int]string=
	//var a map[int]string= map[int]string{1:"lqz",2:"egon",3:"jason"}   //数组初始化，切片初始化，很像
	//var a map[int]string= map[int]string{}   //不是nil类型
	//fmt.Println(a)
	//if a==nil{
	//	fmt.Println("我是空")
	//}

	//var a =make(map[int]string)
	//a :=make(map[int]string)
	//fmt.Println(a)



	//2 给 map 添加元素(有就是更新，没有就是新增)
	//
	////var a map[int]string  // 不能往里添加元素
	////a :=make(map[int]string)
	//var a map[int]string= map[int]string{1:"lqz",2:"egon",3:"jason"}
	////a[1]="lqz"   //往里添加元素
	//////a[1]=123   //类型不匹配
	////a[1]="egon"  // 更新
	//a[9]="xxx"
	//fmt.Println(a)

	//3 获取 map 中的元素
	//var a map[int]string= map[int]string{1:"lqz",2:"egon",3:"jason"}
	//var a map[int]int= map[int]int{1:1,2:0}
	//fmt.Println(a[1])

	//fmt.Println(a[9])  //取不到，会打印出value值的默认值（空值）
	//从字典中取值，其实会返回两个值，一个是true和false，一个是真正的值
	//如果用一个变量来接，就是值（可能为空，可以能有值），两个变量接，一个是值，一个是true和false
	//b:=a[9]
	//b,ok:=a[9]
	//b,ok:=a[1]
	//a[2]=0
	//b,ok:=a[2]
	//fmt.Println(a)
	//fmt.Println(b)
	//fmt.Println(ok)


	//4 删除 map 中的元素
	//var a map[int]string= map[int]string{1:"lqz",2:"egon",3:"jason"}
	//fmt.Println(a)
	////根据key删除值
	//delete(a,1)
	//fmt.Println(a)

	//5 获取 map 的长度(len())
	//var a map[int]string= map[int]string{1:"lqz",2:"egon",3:"jason"}
	//a[9]="999"
	//fmt.Println(len(a))
	//6 Map 是引用类型
	//var a map[int]string= map[int]string{1:"lqz",2:"egon",3:"jason"}
	//fmt.Println(a)
	//test3(a)
	//fmt.Println(a)
	//7 Map 的相等性
	//var a map[int]string= map[int]string{1:"lqz",2:"egon",3:"jason"}
	//var b map[int]string= map[int]string{1:"lqz",2:"egon",3:"jason"}
	//if a==b{  //map不能通过等号来判断，自己写循环，一个个取判断 ，错误的
	//}
	//if a==nil{
	//
	//}

	//补充：map的value值可以是任意类型
	//var a map[int]map[string]string=make(map[int]map[string]string)
	//fmt.Println(a==nil)
	//fmt.Println(a[1]==nil)
	//// 报错了
	////a[1]=make(map[string]string)
	//a[1]= map[string]string{"1":"lqz"}
	////a[1]["1"]="lqz"
	//fmt.Println(a)

	//能听懂听懂，听不懂算了（字典在内存中怎么存的）
	//红黑树
	//var a =make(map[int]string,90)

	//循环map（必须会）
	var a =make(map[int]string)
	a[1]="xx"
	a[2]="uu"
	a[3]="99"
	a[4]="66"
	a[6]="99"
	fmt.Println(a)
	//这种不对
	//for i:=0;i<len(a);i++{
	//	fmt.Println(a[i])
	//}
	//map是无序的  python3.6之前也是无序的，3.6以后有序了，如何做到的
	//for k,v:=range a{
	//	fmt.Println(k)
	//	fmt.Println(v)
	//}


	





}




func test3(a map[int]string)  {
	a[1]="xxxxx"
	fmt.Println(a)
}