array

go语言数组，定义方法如下:

var arr [n]type

• 声明方法

var arr [10]int
arr[0] = 10
arr[1] = 2

//简短声明
a := [3]int{1, 2, 3}
b := [10]int{1, 2, 3}   //声明一个长度为10的int数组， 
                                //其中三个元素为1,2,3其他元素初始值为0
c := [...]int = {1, 2, 3} //可以省略长度，go语言会自动计算长度

• go语言也支持多维数组

doubleArray：= [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
//还可以用下面的方法声明
easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}

slice

slice 是一个引用类型，并不是真正意义上的动态数组，slice总是指向一个底层array，slice的声明可以像array一样，只是不需要长度

//和声明array一样，只是少了长度
var fslice []int

• 声明并slice，并初始化数据

slice := []byte {'a', 'b', 'c', 'd'}

• slice 可以从一个数组或一个已经存在的slice再次声明，slice通过array[i:j]来获取，其中i是数组的开始位置，j是结束位置，但不包含array[j]，它的长度是 j - i

//声明数组
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f'}

//声明slice
var a, b []byte

a = ar[2:4]  //ar[2], ar[4]
b = ar[:4]   //ar[0] , ar[1], ar[2], ar[3]

• slice的使用注意事项和内建函数

func main() {
    //slice 指向数组，声明时不需要加长度
    var fslice, s1 []int
    //如果在初始化的时候没有赋值，用如下方法再次赋值是错误的，slice只是一个引用类型
    //声明并不会分配空间，只是一个指针，只能指向一个数组
    //改变数组或者同指向一个数组的slice中的值，数组或指向同意数组的slice的相应的值都会改变
    /*
    fslice[0] = 10
    fslice[1] = 20
    */
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
    fslice = arr[2:8]
    s1 = arr[:6]
    s1[3] = 100
    arr[5] = 200
    fmt.Println(fslice)
    fmt.Println(s1)
    fmt.Println(arr)

    //slice的内置函数
    fmt.Println(len(s1))  //len 获取slice的内置函数
    s2 := append(s1, 100) //向slice中追加元素并返回新的slice
    fmt.Println(s2)
    var s3 []int
    copy(s2, s3)
    fmt.Println(s3)
    fmt.Println(cap(s1)) //cap获取slice的最多容量，slice的最多容量等于原数组的长度
}

map

• map是无序的，每次打印出来的map都会不一样，它不能通过index获取，而必须通过key获取
• map的长度是不固定的，也就是和slice一样，也是一种引用类型
• 内置的len函数也可用于map，返回map拥有的key数量
• 可以通过 m["key"] 的方式修改map的值

package main

import "fmt"

//map 即python中字典的概念
//map 和slice一样，是一种引用类型
func main() {
    //1.声明一个map，使用之前需要用make来初始化
    var numbers map[string] int
     numbers = make(map[string] int)
    //numbers := make(map[string]int)
    numbers["one"] = 1
    fmt.Println(numbers)

    //2.另外一种初始化方式
    m := make(map[string] int)
    m["one"] = 1
    m["two"] = 2
    m["three"] = 3
    fmt.Println(m)
    fmt.Println(m["one"])

    //2.map的内置函数
    //判断map中是否存在key，存在返回true，不存在返回false
    n, ok := m["one"]
    if ok {
        fmt.Println("one is exite", n)
    } else {
        fmt.Println("one is not exite")
    }

    //删除map中的元素
    delete(m, "three")
    fmt.Println(m)
}