go二维map_Go 数组/多维数组/切片/map #2

◆【循环】

▶for

1，通常

for i=0; I < 5; i++{

fmt.Println(i)

}

2，省略初始值

for ; i < 5; i++{

fmt.Println(i)

}

3,省略初始语句和结束语句

for i < 5{

i++

fmt.Println(i)

}

4，无限循环

for {

fmt.Println("hello")

}

5，break跳出for循环

6，continue继续下一次循环

7，for range循环

▶switch

switchs {

case1:

fmt.Println(s)

case2,3:

fmt.Println(s)

case4,5:

fmt.Println(s)

default:

fmt.Println("over.")

}

▶不常用goto

◆【数组】

▶定义

1，定义数组

vara [3]int

varb [4]int

2，定义时初始化

var testArray = [3]string{"a","b","c"}

3,编译器推导数组长度

var testArray = [...]string{"a","b","c"}

4,使用索引值初始化

var testArray = [...]string{2:"a",4:"b",6:"c"}

▶遍历

1，for循环

for i := 0; i < len(testArray); i++ {

fmt.Println(testArray)

}

2, for range遍历

for index, value := range testArray {

fmt.Println(index, value)

}

只输出索引：

for index := range testArray {

fmt.Println(index)

}

只输出值：

for _, value := range testArray {

fmt.Println(value)

}

◆【多维数组】

1，二维数组

testArray := [2][2]string{

{"a1", "a2"},

{"b1", "b2"},

}

或：

testArray := [2][2]string{

{"a1", "a2"},

{"b1", "b2"}}

多维数组简写：

testArray := [...][2]string{

{"a1", "a2"},

{"b1", "b2"}}

2，遍历二维数组

for_, v1 :=rangetestArray {

for_, v2 :=rangev1 {

fmt.Println(v2)

}

}

▶注意事项

1，数组是值类型，赋值，传参，都是拷贝了一份完整副本。

◆【切片】

1，定义

var s1 []string //声明切片；此时，s1是一个空切片[],长度和容量为0；且s1==nil

var s2 []int{} //声明并且初始化；此时，s1是一个空切片[],长度和容量为0；且s2!=nil

var s3 = []int{1,2,3}

2,基于数组定义切片

a := [5]int{1,2,3,4,5}

切片：b:= a[1:4]

切片再切片：c :=b[1:len(b)]

3, make函数构造切片

a := make([]int, 2, 5) //此切片个数为2，容量为5

a := make([]int, 0) //a != nil

4，通过len()函数获取切片长度

5，通过cap()函数获取切片容量

6,切片不能直接比较。

可以和nil比较，例：s1 == nil

使用len函数判断是否为0.

7,切片的赋值拷贝

切片赋值时，底层数组是一致的。

s1 := make{[] int, 5} //[0,0,0,0,0]

s2 :=s1

s2[0] = 5 //此时，s1[0]值也为5

8，切片扩容；append方法为切片添加元素。

切片声明后，必须初始化，才能使用。

例：

var a []int //声明，并未申请内存。

※可以声明时初始化，也可以使用make函数初始化；也可采用append添加元素。

追加元素(例)：

a = append(a,1,2,3,4)

b := []int{5,6,7}

a = append(a,b...) //注意：b后面需有3个点(...)。

9，copy函数复制切片；此时，二者底层的数组不同。

例：a := []int{1,2,3}

b := make([]int,3,3)

c := b //直接赋值，则c与b共用底层数组，修改b,则修改c.

copy(b,a) //拷贝a到b

b[0] = 10

fmt.Println(a)

fmt.Println(b)

10,切片删除元素

切片没有直接删除操作；间接方法如下：

删除index的元素：append(a[:index], a[index+1:]...)

11，切片排序sort

var a = [...]int{2,4,3,7,5}

sort.Ints(a[:]) //a[:]是一个切片，指向底层数组a.

fmt.Println(a) //上面对切片排序，影响的是底层数组。

◆【map】

1，定义map;

不初始化时为nil；

var a map[string]int //key为string;值为int

a = make(map[string]int,9) //make初始化

b := map[int]boot{ //声明时，初始化

1:true,

2:false,

}

2, 判断键是否存在

map是无序的。

value, ok := socreMap["test1"] //如果test1存在，value返回值，ok为true.

①遍历键，值对

for k, v := range scoreMap {

fmt.Println(k,v)

}

②只遍历key。

for k := range scoreMap {

fmt.Println(k)

}

③只遍历value.

for _, v := range scoreMap {

fmt.Println(v)

}

3,删除键值对

delete(scoreMap,"test1")//使用delete函数，删除scoreMap中的test1键值对。

value := rand.Intn(100) //生成0~99的随机数。

4，其它

值为切片的map;

var sliceMap = make(map[string][]int,8) //只完成了map的初始化，后续使用要初始化切片。