go day2

跳出多层for循环，定义一个flag变量

for i := 0;i < 10; i++{
		var flag = false
		for j := 'a'; j < 'z'; j++{
			if j == 'd'{
				flag = true
				break
			}
			fmt.Printf("%v %c\n",i,j)

		}
		if flag {
			break
		}
	}

goto语句(尽量少用)

//goto + label 实现跳出多层for循环
	for i := 0;i < 10; i++{
		for j := 'a'; j < 'z'; j++{
			if j == 'd'{
				goto XX
				break
			}
			fmt.Printf("%v %c\n",i,j)
		}

	}
XX: //label标签
	fmt.Println("跳出")
}

数组

数组的初始化

	//初始化方式1
	a1 = [3]bool{true,true,false}

	//初始化方式2：根据初始值自动推断数组的长度是多少
	a100 := [...]int{1,2,3,4,5}

	//初始化方式3：根据索引来初始化
	a5 := [5]int{0:1,4:2}
	fmt.Println(a5)

数组遍历和多维数组

citys := [...]string{"北京","上海","深圳"}
	//	1.索引遍历
	for i := 0; i < len(citys);i++ {
		fmt.Println(i,citys[i])
	}

	//2.for range遍历
	for i,v := range citys{
		fmt.Println(i,v)
	}

	//多维数组
	//var a11 [3][2]int
	a11 := [3][2]int{
		[2]int{1,2},
		[2]int{1,2},
		[2]int{1,2},
	}
	fmt.Println(a11)

	//多维数组的遍历
	for _,v1 := range a11{
		fmt.Println(v1)
		for _,v2 := range v1{
			fmt.Println(v2)
		}
	}

	//数组是值类型,可以拷贝
	b1 := [3]int{1,2,3}
	b2 := b1
	b2[0] = 100
	fmt.Println(b1,b2)

切片(slice)

切片的本质

切片就是一个框，框住了一块连续的内存。

切片属于引用类型，真正的数据都是保存在底层数组里的。一经修改所有引用的值都会改变

1.切片指向了一个底层的数组

2.切片的长度就是它元素的个数 len()

4.切片的容量是底层数组从切片的第一个元素到最后一个元素的数量 cap()

切片和数组区别

数组和切片的区别是什么?

1、切片是指针类型，数组是值类型；

2、数组的长度是固定的，而切片不是（切片可以看成动态的数组）；

3、切片比数组多一个容量（cap）属性；

4、切片的底层是数组。

//切片的定义
	var s1 []int //定义一个存放int类型元素的切片
	var s2 []string
	fmt.Printf("%T%T",s1,s2)
	fmt.Println(s1 == nil)
	//初始化
	s1 = []int{1,2,3}
	s2 = []string{"你","我","他"}
	fmt.Println(s1,s2)
	fmt.Println(s1 == nil) //false

	//长度和容量
	fmt.Printf("%d%d",len(s1),cap(s1))
	fmt.Printf("%d%d",len(s2),cap(s2))

	//2.由数组得到切片
	a1 := [...]int{1,2,3,44,2,43,4,3}
	s3 := a1[0:4]
	fmt.Println(s3)
	s5 := a1[:4]
	s6 := a1[3:]
	s7 := a1[:]
	fmt.Println(s5,s6,s7)
	fmt.Println(len(s5),cap(s5))

	s8 := s6[3:]
	fmt.Println("s8",s8)

	a1[6] = 1300
	s6[1] = 12345
	fmt.Println(s6)
	fmt.Println(a1)

make构造切片

s3 := []int{1,2,4}
	s4 := s3
	fmt.Println(s3,s4)
	s4[0] = 1212121
	fmt.Println(s3,s4)

	//切片遍历
	//1.索引遍历
	for i:= 0; i < len(s3);i++{
		fmt.Println(s3[i])
	}
	//2.for range 循环
	for i ,v := range s3{
		fmt.Println(i,v)
	}

append()方法为切片添加元素

s1 := []string{"北京", "上海", "深圳"}
	//调用append函数必须用原来的切片变量接收返回值
	//append追加元素，原来的底层数组放不下的时候，Go底层就会把底层数组换一个
	//必须用变量接收append的返回值
	s1 = append(s1, "广州")
	fmt.Printf("%v%d%d",s1,len(s1),cap(s1))

	ss := []string{"北京1", "上海2", "深圳3"}
	ss = append(ss,s1...) //...是把切片拆开,因为只能添加单个，而s1在此时是切片而不是单个元素
	fmt.Println(ss)

指针

x1 := [...]int{1,3,5} //数组
	ss := x1[:]	//切片
	fmt.Println(ss,len(ss),cap(ss))
	//1.切片不保存具体的值
	//2.切片对应一个底层数组
	//3.底层数组都是占用一块连续的内存
	fmt.Printf("%p\n",&ss[0])
	ss = append(ss[:1],ss[2:]...) //修改底层数组
	fmt.Printf("%p\n",&x1[0])
	fmt.Println(ss,len(ss),cap(ss))

	ss[0] = 100 //修改底层数组
	fmt.Println(x1)

s1 := []int{1,2,3}
	s2 := s1
	//var s3 []int //nil没有空间
	var s4 = make([]int,3,5)
	copy(s4,s1)
	fmt.Println(s1,s2,s4)
	s1[0] = 100
	fmt.Println(s1,s2,s4)

	a := []int{1,2,3,4,5,6,7}
	a = append(a[:2],a[3:]...)
	fmt.Println(a,cap(a)) //[1 2 4 5 6 7] 7 切片不存值，底层数组存值