容器

一、数组

package main

import "fmt"

func main()  {
//这里我们创建一个数组`a`来存放刚好5个`int`
//元素的类型和长度都是数组类型的一部分。数组默认是零值，对于`int`数组来说也就是0
var a [5]int
fmt.Println(a)

//我们可以使用`array[index] = value`语法来设置数组
//指定位置的值，或者用`array[index]`来得到值
a[4] = 100
fmt.Println("set:",a)
fmt.Println("get",a[4])

//使用内置函数`len`返回数组的长度
fmt.Println(len(a))

//使用这个语法在一行内初始化一个数组
b := [5]int{1,2,3,4,5}
fmt.Println("dcl",b)

//数组的存储的类型是单一的，但是你可以组合这些数据来构造多位的数组结构
var two [2][3]int
for i := 0; i &lt; 2; i++ {
for j := 0; j &lt; 3; j++ {
two[i][j] = i+j
}
}
fmt.Println("2d",two)
}

遍历数组：

for k, v := range numComs {
		fmt.Println(k, "-", v)
	}

for _, v := range numComs {
		fmt.Println(v)
	}

for v := range numComs {
		fmt.Println(v)
	}

二、切片

package main

import "fmt"

func main()  {
//不像数组，slice的类型仅有它所包含的元素决定(不像数组中还需要元素个数)
//要创建一个长度非零的空slice，需要内建的方法`make`。
//这里我们创建了一个长度为3的`string`类型的slice(初始化为零值)
s := make([]string,3)
fmt.Println("emp",s)

//我们可以和数组一起设置和得到值
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("set:",s)
fmt.Println("get:",s[2])

//len返回slice的长度
fmt.Println("len",len(s))

//作为基本操作的补充，slice支持比数组更多的操作
//其中一个是内建的`append`,它返回一个包含了一个或者多个新值的slice
//注意我们接受返回有append返回新的slice值
s = append(s,"d")
s = append(s,"e","f")
fmt.Println("apd",s)

//slice也可以被`copy`。这里我们创建一个空的和`s`有相同长度的slice `c`，并且将`s`复制给`c`
c := make([]string,len(s))
copy(c,s)
fmt.Println("cpy:",c)

//slice支持通过`slice[low:high]`来进行切片操作
//例如，这里得到一个包含元素`s[2]`,`s[3]`,`s[4]`的slice
l := s[2:5]
fmt.Println("sl1:",l)

//这个slice从`s[0]`到(但是不包含)`s[5]`
l = s[:5]
fmt.Println("sl2:",l)

//这个slice从(包含)`s[2]`到slice的后一个值
l = s[2:]
fmt.Println("sl3:",l)

//我们可以在一行代码中申明并初始化一个slice变量
t := []string{"g","h","i"}
fmt.Println("dcl:",t)

//slice可以组成多位数据结构。内部的slice长度可以不同，这和多位数组不同
two := make([][]int,3)
for i := 0; i &lt; 3; i++ {
innerLen := i+1
two[i] = make([]int,innerLen)
for j := 0; j &lt; innerLen; j++ {
two[i][j] = i+j
}
}
fmt.Println("2d:",two)
}

常用的切片代码：

初始化：

numComs := [][W][M]int{}

等效于：

combs := make([][W][M]int, 0)

combs := [][]int{n}

等效于

combs := make([][]int, n)

combs := [][]int{}

等效于

combs := make([][]int, 0)

理解：
[][][][][][]int,不管多少维切片（或者数组），只看最后面那个[]int，即最小数组元素的值的类型即可知道是整体什么数组，存放什么类型的数据。

三、关联数组Map

package main

import (
"fmt"
)

func main(){
//要创建一个空map，需要使用内建的make
m := make(map[string]int)

//使用典型的make[key] = val语法来设置键值对
m["k1"] = 7
m["k2"] = 13

//使用例如`println`来打印一个map将会输出所有的键值对
fmt.Println("map:",m)

//使用name[key]来获取一个键的值
v1 := m["k1"]
fmt.Println("v1:",v1)

//内建的delete可以从一个map中移除键值对
delete(m,"k2")
fmt.Println("map:",m)

//当从一个map中取值时，可选的第二返回值指示这个键
//是在这个map中。可以用来消除键不存在和键有零值
//像0或者""产生的歧义
_,prs := m["k2"]
fmt.Println("prs:",prs)

//你也可以通过这个语法在同一行申明和初始化一个新的map
n := map[string]int{"foo":1,"bar":2}
fmt.Println("map:",n)

}

四、Range遍历

package main

import "fmt"

func main()  {
//这里我们使用range来统计一个slice的元素个数
//数组也可以采用这种方法
nums := []int{2,3,4}
sum := 0
for _,num := range nums{
sum += num
}
fmt.Println("sum:",sum)

//range在数组和slice中同样提供每个项的索引和值
//上面我们不需要索引，所以我们使用空值定义符`_`来忽略它
//有时候我们实际上是需要这个索引的
for i,num := range nums{
if num == 3{
fmt.Println("index:",i)
}
}

//range在map中迭代键值树
kvs := map[string]string{"a":"apple","b":"banana"}
for k,v := range kvs{
fmt.Println("%s-&gt;%s\n",k,v)
}

//range在字符串中迭代unicode编码。
//第一个返回值是rune的起始字节位置，然后第二个是rune自己
for i,c := range "go"{
fmt.Println(i,c)
}
}

Related Posts