go语言之行--数组、切片、map

一、内置函数

• append ：追加元素到slice里,返回修改后的slice
• close ：关闭channel
• delete ：从map中删除key对应的value
• panic  ： 用于异常处理，停止常规的goroutine
• recover ：用于异常处理，允许程序定义goroutine的panic动作
• imag ：返回复数(complex)的实部
• real  ： 返回复数(complex)的虚部
• make :用来分配内存，主要分配引用类型，返回Type本身(只能应用于slice, map, channel)
• new ：分配内存，主要分配值类型，返回指向Type的指针，如int
• cap  ：容量，容积capacity
• copy ：复制slice，返回复制的数目
• len ：返回长度

二、数组与切片

概念：同一组数据类型的固定长度的序列

注意：

• 长度数数组类型的一部分，因此var a[2] int 和 var a[3] int是不同的类型
• 数组索引是从0开始(python相同)，访问超过了索引会panic
• 数组定义完成之后，每个位置会有默认值，int类型，默认值为0，string类型默认为空字符串
• 数组属于值类型，当对其进行拷贝并修改副本值时，并不会改变原来的值

定义方法：

//第一种
//var <数组名称> [<数组长度>]<数组元素>
var arr [2]int
    arr[0]=1
    arr[1]=2

//第二种
var a []int
a = make([]int, 4)

//第三种
//var <数组名称> = [<数组长度>]<数组元素>{元素1,元素2,...}
var arr = [2]int{1,2}
//或者
arr := [2]int{1,2}

//第四种
//var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{元素1,元素2,...}
var arr = [...]int{1,2}
//或者
arr := [...]int{1,2}

//第五种
//var <数组名称> [<数组长度>]<数组元素> = [...]<元素类型>{索引1:元素1,索引2:元素2,...}
var arr = [...]int{1:1,0:2}
//或者
arr := [...]int{1:1,0:2}

数组遍历

package main

import "fmt"

func main()  {
    var arr = [...] int {0:2,1:4,2:8}

    for i := 0; i<len(arr); i++ {
        fmt.Println(arr[i])
    }


    }//结果：2,4,8

package main

import "fmt"

func test(a *[3] int )  { //传递地址
    (*a)[0]=100
    return
}

func main()  {
    var arr [3] int
    test(&arr)           //使用&取地址
    fmt.Println(arr[0])


    }//结果：100

package main

import (
"fmt"
)

func fab(n int) {
    var a []int
    a = make([]int, n)

    a[0] = 1
    a[1] = 1

    for i := 2; i < n; i++ {
        a[i] = a[i-1] + a[i-2]
    }
    for _, v := range a {
        fmt.Println(v)
    }
}

func main() {
    fab(5)
}

多维数组

多维数组，相当于多添加了维数

package main

import "fmt"

func main() {
    var a [5][4][3] int  //三维数组
    a[1][1][0]=1
    a[1][0][0]=1
    a[1][1][1]=1
    fmt.Println(a)
}

切片

概念：切片是对数组的引用，数组的长度不便，但是切片长度是可以变化的。

切片的特性和数组一样，因此遍历、长度计算等和数组一样

切片定义和数组的定义方式在于是否有长度定义，有长度定义为数组、没有长度定义为切片

//方式一，使用make创建
slice1 := make([]type, len,capacity)  或者var slice1 []type = make([]type, len,capacity)//其中capacity(容量)为可选参数

//方式二,直接初始化
slice2 :=[] int {1,2} //长度为2，容量为2

//方式三，从数组中获取切片，与python一样
slice3 := arr[startIndex:endIndex] //将arr数组中从下标startIndex到endIndex-1下的元素创建为一个新的切片
slice4 := arr[startIndex:]         //缺省endIndex时将表示一直到arr数组的最后一个元素
slice5 := arr[:endIndex]           //缺省startIndex时将表示从arr数组的第一个元素开始

切片操作

len：计算长度（长度是指已经被赋过值的最大下标+1）

cap：求容量（容量是指切片可容纳的最多元素个数）

copy: 拷贝切片

append：向切片中追加元素

注意事项：

使用append向切片追加元素，如果长度没超过定义的切片的长度，返回原来的切片地址，如果超过了长度，切片会扩容进行重新分配地址。

package main

import "fmt"

func main() {
    var slice2 [] int = make([] int,2,3)
    fmt.Println(len(slice2),cap(slice2))

}//结果 2，3

package main

import "fmt"

func main() {
    var slice1 [] int = make([] int,2,3)
    slice2 :=[] int {2,2,2}

    fmt.Printf("%p--%d\n",slice1,slice1)
    slice1=append(slice1,1)    //追加单个元素
    fmt.Printf("slice1:%p--%d\n",slice1,slice1)
    slice3 :=append(slice1,slice2...) //追加另一个切片
    fmt.Printf("slice3:%p--%d\n",slice3,slice3)
    slice4 := make([] int,len(slice3))
    copy(slice4,slice3)         //拷贝slice3
    fmt.Printf("copy：slice3:%p--%d\n",slice3,slice3)
    fmt.Printf("slice4:%p--%d\n",slice4,slice4)
}

空(nil)切片

一个切片在未初始化之前默认为 nil，长度为 0

 

三、map

概念：map是go语言内置key-value的数据结构，与python的dict类似，可称为字典或关联数组。

map声明与初始化

map属于引用类型，声明是不会分配内存的，需要make初始化分配内存。

//只声明不初始化，直接使用会panic，需要使用make分配内存后方可使用
var a map[keytype]valuetype
var a map[string]string
var a map[string]int
var a map[int]string
var a map[string]map[string]string　

//声明并初始化
var a map[string]string
a = make(map[string]string, 8) //8代表容量

a := make(map[string]string, 8)
a := make(map[string]string)

var a map[string]string = map[string]string{}
var a map[string]string =map[string]string{"name":"wd","age":"22"}

map嵌套

map可以嵌套，类似json格式,声明时候只需要将value改为map，同样使用之前需要初始化每一层的map，示例：

package main

import "fmt"

func main() {
    a := make(map[string]map[string]string,10)  //二层map嵌套，声明外层map并初始化
    a["key1"] = make(map[string]string) //初始化第二层map
    a["key1"]["key2"] = "a1"
    a["key1"]["key3"] = "b1"
    a["key1"]["key4"] = "c1"
    fmt.Println(a)
}

map操作

增删改查、求长度

mymap["name"] = "wd"   // 创建或者更新
delete(mymap, "name")    // 删除
name := mymap["name"]    // 查询 
len(mymap)   // 求长度

//测试key是否存在
package main
import "fmt"
func main() {
    a := make(map[string]string,10)
    a["key1"] = "wd"
    val,ok := a["key1"]   //ok为true时，代表有key
    if ok{
        fmt.Println(val)
    }else {
        fmt.Println("key1 is not exist")
    }

}

遍历map

package main

import (
    "fmt"
)

func main() {
    a := map[string]string{"NAME":"WD","AGE":"22"}
    for k :=range a{   //使用key进行遍历
        fmt.Println(a[k])
    }
    for k,v :=range a{    //使用key，value进行遍历
        fmt.Println(k,v)
    }
}

 切片嵌套map

package main

import "fmt"

func main() {
    a := map[string]string{"NAME":"WD","AGE":"22"} //初始化map
    b := make([]map[string]string,3,3)   //初始化切片
    b[0]=a
    fmt.Println(b)
}

 map排序

go语言中的map都是无序的，并且无内置排序方法，所有如果我们想要对map进行排序，我们需要自己实现。

方法：

• 先获取所有的key，将key进行排序
• 按照排序好的key进行遍历

package main

import (
    "fmt"
    "sort"
)

func main() {
   a:= map[string]string{"1":"a","2":"b","3":"c","4":"d"}
   var keys [] string
   for k := range a{
       keys = append(keys, k)
   }
   sort.Strings(keys)//排序切片key
   fmt.Println(keys,len(keys))
   for _,val := range keys{   //循环key取值
       fmt.Println(a[val])
   }
}