跳出多层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 切片不存值,底层数组存值